@allurereport/plugin-dashboard 3.0.0-beta.12

package/README.md

@@ -0,0 +1,103 @@
+# Dashboard 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 dashboard with trend graphs for Allure reports, allowing you to track test execution statistics over time.
+
+## Install
+
+Use your favorite package manager to install the package:
+
+```shell
+npm add @allurereport/plugin-dashboard
+yarn add @allurereport/plugin-dashboard
+pnpm add @allurereport/plugin-dashboard
+```
+
+Then, add the plugin to the Allure configuration file:
+
+```typescript
+import { defineConfig } from "allure";
+
+export default defineConfig({
+  plugins: {
+    dashboard: {
+      options: {
+        singleFile: false,
+        reportName: "My Dashboard",
+        reportLanguage: "en",
+        layout: [
+          {
+            type: "trend",
+            dataType: "status",
+            mode: "percent"
+          },
+          {
+            type: "pie",
+            title: "Test Results"
+          }
+        ]
+      }
+    }
+  }
+});
+```
+
+## Features
+
+### Available Widgets
+
+#### Trend Charts
+
+Trend charts allow you to track metrics over time. Available configurations:
+
+```typescript
+{
+  type: "trend",
+  dataType: "status",
+  mode: "percent", // optional, default: "raw"
+  limit: 10, // optional: limit number of builds
+  title: "Custom Status Trend", // optional
+  metadata: { // optional
+    executionIdAccessor: (executionOrder) => `build-${executionOrder}`,
+    executionNameAccessor: (executionOrder) => `build #${executionOrder}`
+  }
+}
+```
+
+#### Pie Charts
+
+Pie charts show distribution of test results:
+
+```typescript
+{
+  type: "pie",
+  title: "Custom Pie" // optional
+}
+```
+
+## 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     |
+
+## License
+
+Apache-2.0 

package/dist/charts/severityTrend.d.ts

@@ -0,0 +1,3 @@
+import type { HistoryDataPoint, TestResult } from "@allurereport/core-api";
+import type { SeverityTrendChartData, TrendChartOptions } from "../model.js";
+export declare const getSeverityTrendData: (testResults: TestResult[], reportName: string, historyPoints: HistoryDataPoint[], chartOptions: TrendChartOptions) => SeverityTrendChartData;

package/dist/charts/severityTrend.js

@@ -0,0 +1,46 @@
+import { severityLabelName, severityLevels } from "@allurereport/core-api";
+import { createEmptySeries, createEmptyStats, getTrendDataGeneric, mergeTrendDataGeneric, normalizeStatistic, } from "../utils/trend.js";
+export const getSeverityTrendData = (testResults, reportName, historyPoints, chartOptions) => {
+    const { limit } = chartOptions;
+    const historyLimit = limit && limit > 0 ? Math.max(0, limit - 1) : undefined;
+    const limitedHistoryPoints = historyLimit !== undefined ? historyPoints.slice(-historyLimit) : historyPoints;
+    const firstOriginalIndex = historyLimit !== undefined ? Math.max(0, historyPoints.length - historyLimit) : 0;
+    const convertedHistoryPoints = limitedHistoryPoints.map((point, index) => {
+        const originalIndex = firstOriginalIndex + index;
+        return {
+            name: point.name,
+            originalIndex,
+            statistic: Object.values(point.testResults).reduce((stat, test) => {
+                const severityLabel = test.labels?.find((label) => label.name === severityLabelName);
+                const severity = severityLabel?.value?.toLowerCase();
+                if (severity) {
+                    stat[severity] = (stat[severity] ?? 0) + 1;
+                }
+                return stat;
+            }, createEmptyStats(severityLevels)),
+        };
+    });
+    const currentSeverityStats = testResults.reduce((acc, test) => {
+        const severityLabel = test.labels.find((label) => label.name === severityLabelName);
+        const severity = severityLabel?.value?.toLowerCase();
+        if (severity) {
+            acc[severity] = (acc[severity] ?? 0) + 1;
+        }
+        return acc;
+    }, createEmptyStats(severityLevels));
+    const currentTrendData = getTrendDataGeneric(normalizeStatistic(currentSeverityStats, severityLevels), reportName, historyPoints.length + 1, severityLevels, chartOptions);
+    const historicalTrendData = convertedHistoryPoints.reduce((acc, historyPoint) => {
+        const trendDataPart = getTrendDataGeneric(normalizeStatistic(historyPoint.statistic, severityLevels), historyPoint.name, historyPoint.originalIndex + 1, severityLevels, chartOptions);
+        return mergeTrendDataGeneric(acc, trendDataPart, severityLevels);
+    }, {
+        type: chartOptions.type,
+        dataType: chartOptions.dataType,
+        title: chartOptions.title,
+        points: {},
+        slices: {},
+        series: createEmptySeries(severityLevels),
+        min: Infinity,
+        max: -Infinity,
+    });
+    return mergeTrendDataGeneric(historicalTrendData, currentTrendData, severityLevels);
+};

package/dist/charts/statusPie.d.ts

@@ -0,0 +1,9 @@
+import type { Statistic } from "@allurereport/core-api";
+import type { PieArcDatum } from "d3-shape";
+import { type PieChartData, type PieChartOptions, type PieSlice } from "../model.js";
+type BasePieSlice = Pick<PieSlice, "status" | "count">;
+export declare const d3Arc: import("d3-shape").Arc<any, PieArcDatum<BasePieSlice>>;
+export declare const d3Pie: import("d3-shape").Pie<any, BasePieSlice>;
+export declare const getPercentage: (value: number, total: number) => number;
+export declare const getPieChartData: (stats: Statistic, chartOptions: PieChartOptions) => PieChartData;
+export {};

package/dist/charts/statusPie.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 const getPercentage = (value, total) => Math.floor((value / total) * 10000) / 100;
+export const getPieChartData = (stats, chartOptions) => {
+    const convertedStatuses = statusesList
+        .filter((status) => !!stats?.[status])
+        .map((status) => ({
+        status,
+        count: stats[status],
+    }));
+    const arcsData = d3Pie(convertedStatuses);
+    const slices = arcsData.map((arcData) => ({
+        d: d3Arc(arcData),
+        ...arcData.data,
+    }));
+    const percentage = getPercentage(stats.passed ?? 0, stats.total);
+    return {
+        type: chartOptions.type,
+        title: chartOptions?.title,
+        slices,
+        percentage,
+    };
+};

package/dist/charts/statusTrend.d.ts

@@ -0,0 +1,3 @@
+import type { HistoryDataPoint, Statistic } from "@allurereport/core-api";
+import type { StatusTrendChartData, TrendChartOptions } from "../model.js";
+export declare const getStatusTrendData: (currentStatistic: Statistic, reportName: string, historyPoints: HistoryDataPoint[], chartOptions: TrendChartOptions) => StatusTrendChartData;

package/dist/charts/statusTrend.js

@@ -0,0 +1,37 @@
+import { statusesList } from "@allurereport/core-api";
+import { createEmptySeries, createEmptyStats, getTrendDataGeneric, mergeTrendDataGeneric, normalizeStatistic, } from "../utils/trend.js";
+export const getStatusTrendData = (currentStatistic, reportName, historyPoints, chartOptions) => {
+    const { limit } = chartOptions;
+    const historyLimit = limit && limit > 0 ? Math.max(0, limit - 1) : undefined;
+    const limitedHistoryPoints = historyLimit !== undefined ? historyPoints.slice(-historyLimit) : historyPoints;
+    const firstOriginalIndex = historyLimit !== undefined ? Math.max(0, historyPoints.length - historyLimit) : 0;
+    const convertedHistoryPoints = limitedHistoryPoints.map((point, index) => {
+        const originalIndex = firstOriginalIndex + index;
+        return {
+            name: point.name,
+            originalIndex,
+            statistic: Object.values(point.testResults).reduce((stat, test) => {
+                if (test.status) {
+                    stat[test.status] = (stat[test.status] ?? 0) + 1;
+                    stat.total = (stat.total ?? 0) + 1;
+                }
+                return stat;
+            }, { total: 0, ...createEmptyStats(statusesList) }),
+        };
+    });
+    const currentTrendData = getTrendDataGeneric(normalizeStatistic(currentStatistic, statusesList), reportName, historyPoints.length + 1, statusesList, chartOptions);
+    const historicalTrendData = convertedHistoryPoints.reduce((acc, historyPoint) => {
+        const trendDataPart = getTrendDataGeneric(normalizeStatistic(historyPoint.statistic, statusesList), historyPoint.name, historyPoint.originalIndex + 1, statusesList, chartOptions);
+        return mergeTrendDataGeneric(acc, trendDataPart, statusesList);
+    }, {
+        type: chartOptions.type,
+        dataType: chartOptions.dataType,
+        title: chartOptions.title,
+        points: {},
+        slices: {},
+        series: createEmptySeries(statusesList),
+        min: Infinity,
+        max: -Infinity,
+    });
+    return mergeTrendDataGeneric(historicalTrendData, currentTrendData, statusesList);
+};

package/dist/generators.d.ts

@@ -0,0 +1,13 @@
+import type { AllureStore, PluginContext, ReportFiles } from "@allurereport/plugin-api";
+import type { DashboardOptions, DashboardPluginOptions, GeneratedChartsData, TemplateManifest } from "./model.js";
+import type { DashboardDataWriter, ReportFile } from "./writer.js";
+export declare const readTemplateManifest: (singleFileMode?: boolean) => Promise<TemplateManifest>;
+export declare const generateCharts: (options: DashboardPluginOptions, store: AllureStore, context: PluginContext) => Promise<GeneratedChartsData | undefined>;
+export declare const generateAllCharts: (writer: DashboardDataWriter, store: AllureStore, options: DashboardPluginOptions, context: PluginContext) => Promise<void>;
+export declare const generateStaticFiles: (payload: DashboardOptions & {
+    allureVersion: string;
+    reportFiles: ReportFiles;
+    reportDataFiles: ReportFile[];
+    reportUuid: string;
+    reportName: string;
+}) => Promise<void>;

package/dist/generators.js

@@ -0,0 +1,153 @@
+import { createBaseUrlScript, createFontLinkTag, createReportDataScript, createScriptTag, createStylesLinkTag, } from "@allurereport/web-commons";
+import { randomUUID } from "crypto";
+import Handlebars from "handlebars";
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { basename, join } from "node:path";
+import { getSeverityTrendData } from "./charts/severityTrend.js";
+import { getPieChartData } from "./charts/statusPie.js";
+import { getStatusTrendData } from "./charts/statusTrend.js";
+import { ChartData, ChartType } from "./model.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": "dashboard",
+          "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-dashboard/dist/${singleFileMode ? "single" : "multi"}/manifest.json`);
+    const templateManifest = await readFile(templateManifestSource, { encoding: "utf-8" });
+    return JSON.parse(templateManifest);
+};
+const generateTrendChart = (options, stores, context) => {
+    const { dataType } = options;
+    const { statistic, historyDataPoints, testResults } = stores;
+    if (dataType === ChartData.Status) {
+        return getStatusTrendData(statistic, context.reportName, historyDataPoints, options);
+    }
+    else if (dataType === ChartData.Severity) {
+        return getSeverityTrendData(testResults, context.reportName, historyDataPoints, options);
+    }
+};
+const generatePieChart = (options, stores) => {
+    const { statistic } = stores;
+    return getPieChartData(statistic, options);
+};
+export const generateCharts = async (options, store, context) => {
+    const { layout } = options;
+    if (!layout) {
+        return undefined;
+    }
+    const historyDataPoints = await store.allHistoryDataPoints();
+    const statistic = await store.testsStatistic();
+    const testResults = await store.allTestResults();
+    return layout.reduce((acc, chartOptions) => {
+        const chartId = randomUUID();
+        let chart;
+        if (chartOptions.type === ChartType.Trend) {
+            chart = generateTrendChart(chartOptions, {
+                historyDataPoints,
+                statistic,
+                testResults,
+            }, context);
+        }
+        else if (chartOptions.type === ChartType.Pie) {
+            chart = generatePieChart(chartOptions, { statistic });
+        }
+        if (chart) {
+            acc[chartId] = chart;
+        }
+        return acc;
+    }, {});
+};
+export const generateAllCharts = async (writer, store, options, context) => {
+    const charts = await generateCharts(options, store, context);
+    if (charts && Object.keys(charts).length > 0) {
+        await writer.writeWidget("charts.json", charts);
+    }
+};
+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-dashboard/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-dashboard/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,
+        allureVersion,
+    };
+    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 @@
+export { DashboardPlugin as default } from "./plugin.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { DashboardPlugin as default } from "./plugin.js";

package/dist/model.d.ts

@@ -0,0 +1,92 @@
+import type { SeverityLevel, TestResult, TestStatus } from "@allurereport/core-api";
+export declare enum ChartType {
+    Trend = "trend",
+    Pie = "pie"
+}
+export declare enum ChartData {
+    Status = "status",
+    Severity = "severity"
+}
+export type ChartMode = "raw" | "percent";
+export type ChartId = string;
+export type ExecutionIdFn = (executionOrder: number) => string;
+export type ExecutionNameFn = (executionOrder: number) => string;
+export type TrendMetadataFnOverrides = {
+    executionIdAccessor?: ExecutionIdFn;
+    executionNameAccessor?: ExecutionNameFn;
+};
+export type TrendChartOptions = {
+    type: ChartType.Trend;
+    dataType: ChartData;
+    mode?: ChartMode;
+    title?: string;
+    limit?: number;
+    metadata?: TrendMetadataFnOverrides;
+};
+export type TrendPointId = string;
+export type TrendSliceId = string;
+export type BaseMetadata = Record<string, unknown>;
+export interface BaseTrendSliceMetadata extends Record<string, unknown> {
+    executionId: string;
+    executionName: string;
+}
+export type TrendSliceMetadata<Metadata extends BaseMetadata> = BaseTrendSliceMetadata & Metadata;
+export type TrendPoint = {
+    x: string;
+    y: number;
+};
+export type TrendSlice<Metadata extends BaseMetadata> = {
+    min: number;
+    max: number;
+    metadata: TrendSliceMetadata<Metadata>;
+};
+export type GenericTrendChartData<Metadata extends BaseMetadata, SeriesType extends string> = {
+    type: ChartType.Trend;
+    dataType: ChartData;
+    title?: string;
+    points: Record<TrendPointId, TrendPoint>;
+    slices: Record<TrendSliceId, TrendSlice<Metadata>>;
+    series: Record<SeriesType, TrendPointId[]>;
+    min: number;
+    max: number;
+};
+export interface StatusMetadata extends BaseTrendSliceMetadata {
+}
+export type StatusTrendSliceMetadata = TrendSliceMetadata<StatusMetadata>;
+export type StatusTrendSlice = TrendSlice<StatusTrendSliceMetadata>;
+export type StatusTrendChartData = GenericTrendChartData<StatusTrendSliceMetadata, TestStatus>;
+export interface SeverityMetadata extends BaseTrendSliceMetadata {
+}
+export type SeverityTrendSliceMetadata = TrendSliceMetadata<SeverityMetadata>;
+export type SeverityTrendSlice = TrendSlice<SeverityTrendSliceMetadata>;
+export type SeverityTrendChartData = GenericTrendChartData<SeverityTrendSliceMetadata, SeverityLevel>;
+export type TrendChartData = StatusTrendChartData | SeverityTrendChartData;
+export type PieChartOptions = {
+    type: ChartType.Pie;
+    title?: string;
+};
+export type PieSlice = {
+    status: TestStatus;
+    count: number;
+    d: string | null;
+};
+export type PieChartData = {
+    type: ChartType.Pie;
+    title?: string;
+    slices: PieSlice[];
+    percentage: number;
+};
+export type GeneratedChartData = TrendChartData | PieChartData;
+export type GeneratedChartsData = Record<ChartId, GeneratedChartData>;
+export type ChartOptions = TrendChartOptions | PieChartOptions;
+export type DashboardOptions = {
+    reportName?: string;
+    singleFile?: boolean;
+    logo?: string;
+    theme?: "light" | "dark";
+    reportLanguage?: "en" | "ru";
+    layout?: ChartOptions[];
+    filter?: (testResult: TestResult) => boolean;
+};
+export type DashboardPluginOptions = DashboardOptions;
+export type TemplateManifest = Record<string, string>;

package/dist/model.js

@@ -0,0 +1,10 @@
+export var ChartType;
+(function (ChartType) {
+    ChartType["Trend"] = "trend";
+    ChartType["Pie"] = "pie";
+})(ChartType || (ChartType = {}));
+export var ChartData;
+(function (ChartData) {
+    ChartData["Status"] = "status";
+    ChartData["Severity"] = "severity";
+})(ChartData || (ChartData = {}));

package/dist/plugin.d.ts

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

package/dist/plugin.js

@@ -0,0 +1,65 @@
+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 _DashboardPlugin_writer, _DashboardPlugin_generate;
+import { getWorstStatus } from "@allurereport/core-api";
+import { generateAllCharts, generateStaticFiles } from "./generators.js";
+import { InMemoryDashboardDataWriter, ReportFileDashboardDataWriter } from "./writer.js";
+export class DashboardPlugin {
+    constructor(options = {}) {
+        this.options = options;
+        _DashboardPlugin_writer.set(this, void 0);
+        _DashboardPlugin_generate.set(this, async (context, store) => {
+            await generateAllCharts(__classPrivateFieldGet(this, _DashboardPlugin_writer, "f"), store, this.options, context);
+            const reportDataFiles = this.options.singleFile ? __classPrivateFieldGet(this, _DashboardPlugin_writer, "f").reportFiles() : [];
+            await generateStaticFiles({
+                ...this.options,
+                allureVersion: context.allureVersion,
+                reportFiles: context.reportFiles,
+                reportDataFiles,
+                reportUuid: context.reportUuid,
+                reportName: context.reportName,
+            });
+        });
+        this.start = async (context) => {
+            if (this.options.singleFile) {
+                __classPrivateFieldSet(this, _DashboardPlugin_writer, new InMemoryDashboardDataWriter(), "f");
+            }
+            else {
+                __classPrivateFieldSet(this, _DashboardPlugin_writer, new ReportFileDashboardDataWriter(context.reportFiles), "f");
+            }
+        };
+        this.update = async (context, store) => {
+            if (!__classPrivateFieldGet(this, _DashboardPlugin_writer, "f")) {
+                throw new Error("call start first");
+            }
+            await __classPrivateFieldGet(this, _DashboardPlugin_generate, "f").call(this, context, store);
+        };
+        this.done = async (context, store) => {
+            if (!__classPrivateFieldGet(this, _DashboardPlugin_writer, "f")) {
+                throw new Error("call start first");
+            }
+            await __classPrivateFieldGet(this, _DashboardPlugin_generate, "f").call(this, context, store);
+        };
+    }
+    async info(context, store) {
+        const allTrs = (await store.allTestResults()).filter(this.options.filter ? this.options.filter : () => true);
+        const duration = allTrs.reduce((acc, { duration: trDuration = 0 }) => acc + trDuration, 0);
+        const worstStatus = getWorstStatus(allTrs.map(({ status }) => status));
+        return {
+            name: this.options.reportName || context.reportName,
+            stats: await store.testsStatistic(this.options.filter),
+            status: worstStatus ?? "passed",
+            duration,
+        };
+    }
+}
+_DashboardPlugin_writer = new WeakMap(), _DashboardPlugin_generate = new WeakMap();

package/dist/utils/trend.d.ts

@@ -0,0 +1,9 @@
+import type { SeverityLevel, TestStatus } from "@allurereport/core-api";
+import type { BaseTrendSliceMetadata, GenericTrendChartData, TrendChartOptions } from "../model.js";
+type TrendDataType = TestStatus | SeverityLevel;
+export declare const createEmptyStats: <T extends TrendDataType>(items: readonly T[]) => Record<T, number>;
+export declare const createEmptySeries: <T extends TrendDataType>(items: readonly T[]) => Record<T, string[]>;
+export declare const normalizeStatistic: <T extends TrendDataType>(statistic: Partial<Record<T, number>>, itemType: readonly T[]) => Record<T, number>;
+export declare const mergeTrendDataGeneric: <M extends BaseTrendSliceMetadata, T extends TrendDataType>(trendData: GenericTrendChartData<M, T>, trendDataPart: GenericTrendChartData<M, T>, itemType: readonly T[]) => GenericTrendChartData<M, T>;
+export declare const getTrendDataGeneric: <M extends BaseTrendSliceMetadata, T extends TrendDataType>(stats: Record<T, number>, reportName: string, executionOrder: number, itemType: readonly T[], chartOptions: TrendChartOptions) => GenericTrendChartData<M, T>;
+export {};

package/dist/utils/trend.js

@@ -0,0 +1,100 @@
+export const createEmptyStats = (items) => items.reduce((acc, item) => ({ ...acc, [item]: 0 }), {});
+export const createEmptySeries = (items) => items.reduce((acc, item) => ({ ...acc, [item]: [] }), {});
+export const normalizeStatistic = (statistic, itemType) => {
+    return itemType.reduce((acc, item) => {
+        acc[item] = statistic[item] ?? 0;
+        return acc;
+    }, {});
+};
+const calculateRawValues = (stats, executionId, itemType) => {
+    const points = {};
+    const series = createEmptySeries(itemType);
+    itemType.forEach((item) => {
+        const pointId = `${executionId}-${item}`;
+        const value = stats[item] ?? 0;
+        points[pointId] = {
+            x: executionId,
+            y: value,
+        };
+        series[item].push(pointId);
+    });
+    return { points, series };
+};
+const calculatePercentValues = (stats, executionId, itemType) => {
+    const points = {};
+    const series = createEmptySeries(itemType);
+    const values = Object.values(stats);
+    const total = values.reduce((sum, value) => sum + value, 0);
+    if (total === 0) {
+        return { points, series };
+    }
+    itemType.forEach((item) => {
+        const pointId = `${executionId}-${item}`;
+        const value = stats[item] ?? 0;
+        points[pointId] = {
+            x: executionId,
+            y: (value / total) * 100,
+        };
+        series[item].push(pointId);
+    });
+    return { points, series };
+};
+export const mergeTrendDataGeneric = (trendData, trendDataPart, itemType) => {
+    return {
+        ...trendData,
+        points: {
+            ...trendData.points,
+            ...trendDataPart.points,
+        },
+        slices: {
+            ...trendData.slices,
+            ...trendDataPart.slices,
+        },
+        series: Object.entries(trendDataPart.series).reduce((series, [group, pointIds]) => {
+            if (Array.isArray(pointIds)) {
+                return {
+                    ...series,
+                    [group]: [...(trendData.series?.[group] || []), ...pointIds],
+                };
+            }
+            return series;
+        }, trendData.series || createEmptySeries(itemType)),
+        min: Math.min(trendData.min ?? Infinity, trendDataPart.min),
+        max: Math.max(trendData.max ?? -Infinity, trendDataPart.max),
+    };
+};
+export const getTrendDataGeneric = (stats, reportName, executionOrder, itemType, chartOptions) => {
+    const { type, dataType, title, mode = "raw", metadata = {} } = chartOptions;
+    const { executionIdAccessor, executionNameAccessor } = metadata;
+    const executionId = executionIdAccessor ? executionIdAccessor(executionOrder) : `execution-${executionOrder}`;
+    const { points, series } = mode === "percent"
+        ? calculatePercentValues(stats, executionId, itemType)
+        : calculateRawValues(stats, executionId, itemType);
+    const slices = {};
+    const pointsAsArray = Object.values(points);
+    const pointsCount = pointsAsArray.length;
+    const values = pointsAsArray.map((point) => point.y);
+    const min = pointsCount ? Math.min(...values) : 0;
+    const max = pointsCount ? Math.max(...values) : 0;
+    if (pointsCount > 0) {
+        const executionName = executionNameAccessor ? executionNameAccessor(executionOrder) : reportName;
+        slices[executionId] = {
+            min,
+            max,
+            metadata: {
+                executionId,
+                executionName,
+            },
+        };
+    }
+    return {
+        type,
+        dataType,
+        title,
+        points,
+        slices,
+        series,
+        min,
+        max,
+    };
+};

package/dist/writer.d.ts

@@ -0,0 +1,23 @@
+import type { ReportFiles } from "@allurereport/plugin-api";
+export type ReportFile = {
+    name: string;
+    value: string;
+};
+export interface DashboardDataWriter {
+    writeWidget<T>(fileName: string, data: T): Promise<void>;
+}
+export declare class FileSystemReportDataWriter implements DashboardDataWriter {
+    private readonly output;
+    constructor(output: string);
+    writeWidget<T>(fileName: string, data: T): Promise<void>;
+}
+export declare class InMemoryDashboardDataWriter implements DashboardDataWriter {
+    #private;
+    writeWidget<T>(fileName: string, data: T): Promise<void>;
+    reportFiles(): ReportFile[];
+}
+export declare class ReportFileDashboardDataWriter implements DashboardDataWriter {
+    readonly reportFiles: ReportFiles;
+    constructor(reportFiles: ReportFiles);
+    writeWidget<T>(fileName: string, data: T): Promise<void>;
+}

package/dist/writer.js

@@ -0,0 +1,43 @@
+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 _InMemoryDashboardDataWriter_data;
+import { mkdir, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { join as joinPosix } from "node:path/posix";
+export class FileSystemReportDataWriter {
+    constructor(output) {
+        this.output = output;
+    }
+    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" });
+    }
+}
+export class InMemoryDashboardDataWriter {
+    constructor() {
+        _InMemoryDashboardDataWriter_data.set(this, {});
+    }
+    async writeWidget(fileName, data) {
+        const dist = joinPosix("widgets", fileName);
+        __classPrivateFieldGet(this, _InMemoryDashboardDataWriter_data, "f")[dist] = Buffer.from(JSON.stringify(data), "utf-8");
+    }
+    reportFiles() {
+        return Object.keys(__classPrivateFieldGet(this, _InMemoryDashboardDataWriter_data, "f")).map((key) => ({
+            name: key,
+            value: __classPrivateFieldGet(this, _InMemoryDashboardDataWriter_data, "f")[key].toString("base64"),
+        }));
+    }
+}
+_InMemoryDashboardDataWriter_data = new WeakMap();
+export class ReportFileDashboardDataWriter {
+    constructor(reportFiles) {
+        this.reportFiles = reportFiles;
+    }
+    async writeWidget(fileName, data) {
+        await this.reportFiles.addFile(joinPosix("widgets", fileName), Buffer.from(JSON.stringify(data), "utf-8"));
+    }
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@allurereport/plugin-dashboard",
+  "version": "3.0.0-beta.12",
+  "description": "Allure Dashboard Plugin – plugin for generating dashboard with a mix of charts",
+  "keywords": [
+    "allure",
+    "testing",
+    "report",
+    "plugin",
+    "dashboard",
+    "charts",
+    "trends"
+  ],
+  "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.12",
+    "@allurereport/plugin-api": "3.0.0-beta.12",
+    "@allurereport/web-commons": "3.0.0-beta.12",
+    "@allurereport/web-dashboard": "3.0.0-beta.12",
+    "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.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"
+  }
+}