@allurereport/plugin-awesome 3.0.0-beta.9 → 3.0.0

package/README.md

@@ -47,11 +47,13 @@ export default defineConfig({
 
 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`     |
+| 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 \| auto`                                      | `auto` 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`                   |
+| `groupBy`      | Grouping tests by labels or combining labels. By default, tests are grouped using the `titlePath` provided by the test framework. | `string`                                                      | `[]`(Grouping by `titlepath`) |
+| `appendTitlePath`| Special marker for `groupBy`. Forces a final grouping by `titlePath` after all label-based groups.                                                          | `boolean`                                                    | `false`                       |

package/dist/converters.d.ts

@@ -1,5 +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;
+import type { AwesomeFixtureResult, AwesomeTestResult, AwesomeTestStepResult } from "@allurereport/web-awesome";
+export declare const convertTestResult: (tr: TestResult) => AwesomeTestResult;
+export declare const convertTestStepResult: (tsr: TestStepResult) => AwesomeTestStepResult;
+export declare const convertFixtureResult: (fr: TestFixtureResult) => AwesomeFixtureResult;

package/dist/converters.js

@@ -27,12 +27,16 @@ export const convertTestResult = (tr) => {
         links: tr.links,
         steps: tr.steps,
         error: tr.error,
+        testCase: tr.testCase,
+        environment: tr.environment,
         setup: [],
         teardown: [],
         history: [],
         retries: [],
         breadcrumbs: [],
         retry: false,
+        transition: tr.transition,
+        titlePath: tr.titlePath || [],
     };
 };
 export const convertTestStepResult = (tsr) => {

package/dist/environments.d.ts

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

package/dist/environments.js

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

package/dist/generateTimeline.d.ts

@@ -0,0 +1,7 @@
+import type { AllureStore } from "@allurereport/plugin-api";
+import type { AwesomeOptions } from "./model.js";
+type Writer = {
+    writeWidget(fileName: string, data: any): Promise<void>;
+};
+export declare const generateTimeline: (writer: Writer, store: AllureStore, options: AwesomeOptions) => Promise<void>;
+export {};

package/dist/generateTimeline.js

@@ -0,0 +1,40 @@
+import { hasLabels } from "@allurereport/web-commons";
+const DEFAULT_MIN_DURATION = 1;
+const HOST_LABEL = "host";
+const THREAD_LABEL = "thread";
+const DEFAULT_TIMELINE_OPTIONS = {
+    minDuration: DEFAULT_MIN_DURATION,
+};
+export const generateTimeline = async (writer, store, options) => {
+    const { timeline = DEFAULT_TIMELINE_OPTIONS } = options;
+    const { minDuration = DEFAULT_MIN_DURATION } = timeline;
+    const testResults = await store.allTestResults({ includeHidden: true });
+    const result = [];
+    for (const test of testResults) {
+        const hasStart = Number.isInteger(test.start);
+        const hasStop = Number.isInteger(test.stop);
+        if (!hasStart || !hasStop) {
+            continue;
+        }
+        const duration = test.duration ?? test.stop - test.start;
+        if (duration < minDuration) {
+            continue;
+        }
+        if (!hasLabels(test, [HOST_LABEL, THREAD_LABEL])) {
+            continue;
+        }
+        result.push({
+            id: test.id,
+            historyId: test.historyId,
+            name: test.name,
+            status: test.status,
+            hidden: test.hidden,
+            labels: test.labels,
+            environment: test.environment,
+            start: test.start,
+            stop: test.stop,
+            duration,
+        });
+    }
+    await writer.writeWidget("timeline.json", result);
+};

package/dist/generators.d.ts

@@ -1,20 +1,39 @@
-import { type AttachmentLink, type EnvironmentItem, type Statistic } from "@allurereport/core-api";
-import { type AllureStore, type ReportFiles, type ResultFile } from "@allurereport/plugin-api";
-import type { AllureAwesomeTestResult } from "@allurereport/web-awesome";
-import type { AllureAwesomeOptions, TemplateManifest } from "./model.js";
-import type { AllureAwesomeDataWriter, ReportFile } from "./writer.js";
+import { type AttachmentLink, type EnvironmentItem, type Statistic, type TestEnvGroup, type TestError, type TestResult } from "@allurereport/core-api";
+import type { AllureStore, ExitCode, PluginContext, QualityGateValidationResult, ReportFiles, ResultFile, TestResultFilter } from "@allurereport/plugin-api";
+import type { AwesomeTestResult } from "@allurereport/web-awesome";
+import type { AwesomeOptions, TemplateManifest } from "./model.js";
+import type { AwesomeDataWriter, ReportFile } from "./writer.js";
 export declare const readTemplateManifest: (singleFileMode?: boolean) => Promise<TemplateManifest>;
-export declare const generateTestResults: (writer: AllureAwesomeDataWriter, store: AllureStore) => Promise<AllureAwesomeTestResult[]>;
-export declare const generateTree: (writer: AllureAwesomeDataWriter, treeName: string, labels: string[], tests: AllureAwesomeTestResult[]) => 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 & {
+export declare const generateTestResults: (writer: AwesomeDataWriter, store: AllureStore, trs: TestResult[], filter?: TestResultFilter) => Promise<AwesomeTestResult[]>;
+export declare const generateTestCases: (writer: AwesomeDataWriter, trs: AwesomeTestResult[]) => Promise<void>;
+export declare const generateTestEnvGroups: (writer: AwesomeDataWriter, groups: TestEnvGroup[]) => Promise<void>;
+export declare const generateNav: (writer: AwesomeDataWriter, trs: AwesomeTestResult[], filename?: string) => Promise<void>;
+export declare const generateTree: (writer: AwesomeDataWriter, treeFilename: string, labels: string[], tests: AwesomeTestResult[], options?: {
+    appendTitlePath?: boolean;
+}) => Promise<void>;
+export declare const generateEnvironmentJson: (writer: AwesomeDataWriter, env: EnvironmentItem[]) => Promise<void>;
+export declare const generateEnvirontmentsList: (writer: AwesomeDataWriter, store: AllureStore) => Promise<void>;
+export declare const generateVariables: (writer: AwesomeDataWriter, store: AllureStore) => Promise<void>;
+export declare const generateStatistic: (writer: AwesomeDataWriter, data: {
+    stats: Statistic;
+    statsByEnv: Map<string, Statistic>;
+    envs: string[];
+}) => Promise<void>;
+export declare const generateAttachmentsFiles: (writer: AwesomeDataWriter, attachmentLinks: AttachmentLink[], contentFunction: (id: string) => Promise<ResultFile | undefined>) => Promise<Map<string, string> | undefined>;
+export declare const generateHistoryDataPoints: (writer: AwesomeDataWriter, store: AllureStore) => Promise<Map<string, string>>;
+export declare const generateGlobals: (writer: AwesomeDataWriter, payload: {
+    globalExitCode?: ExitCode;
+    globalAttachments?: AttachmentLink[];
+    globalErrors?: TestError[];
+    contentFunction: (id: string) => Promise<ResultFile | undefined>;
+}) => Promise<void>;
+export declare const generateQualityGateResults: (writer: AwesomeDataWriter, qualityGateResults?: QualityGateValidationResult[]) => Promise<void>;
+export declare const generateStaticFiles: (payload: AwesomeOptions & {
+    id: string;
     allureVersion: string;
     reportFiles: ReportFiles;
     reportDataFiles: ReportFile[];
     reportUuid: string;
     reportName: string;
 }) => Promise<void>;
+export declare const generateAllCharts: (writer: AwesomeDataWriter, store: AllureStore, options: AwesomeOptions, context: PluginContext) => Promise<void>;

package/dist/generators.js

@@ -1,12 +1,12 @@
-import { compareBy, incrementStatistic, nullsLast, ordinal, } from "@allurereport/core-api";
-import { filterTree } from "@allurereport/plugin-api";
-import { createTreeByLabels, sortTree, transformTree } from "@allurereport/plugin-api";
-import { createBaseUrlScript, createFontLinkTag, createReportDataScript, createScriptTag, createStylesLinkTag, } from "@allurereport/web-commons";
+import { defaultChartsConfig } from "@allurereport/charts-api";
+import { compareBy, createBaseUrlScript, createFontLinkTag, createReportDataScript, createScriptTag, createStylesLinkTag, incrementStatistic, nullsLast, ordinal, } from "@allurereport/core-api";
+import { createTreeByLabels, createTreeByLabelsAndTitlePath, createTreeByTitlePath, filterTree, preciseTreeLabels, sortTree, transformTree, } from "@allurereport/plugin-api";
+import { generateCharts, getPieChartValues } from "@allurereport/web-commons";
 import Handlebars from "handlebars";
+import { randomUUID } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { basename, join } from "node:path";
-import { getChartData } from "./charts.js";
 import { convertFixtureResult, convertTestResult } from "./converters.js";
 const require = createRequire(import.meta.url);
 const template = `<!DOCTYPE html>
@@ -14,7 +14,7 @@ const template = `<!DOCTYPE html>
 <head>
     <meta charset="utf-8">
     <title> {{ reportName }} </title>
-    <link rel="icon" href="favicon.ico">
+    <link rel="icon" href="data:image/svg+xml,%3Csvg width='32' height='32' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath fill-rule='evenodd' clip-rule='evenodd' d='M22.232 4.662a3.6 3.6 0 0 1 5.09.035c2.855 2.894 4.662 6.885 4.662 11.295a3.6 3.6 0 0 1-7.2 0c0-2.406-.981-4.61-2.587-6.24a3.6 3.6 0 0 1 .035-5.09Z' fill='url(%23a)'/%3E%3Cpath fill-rule='evenodd' clip-rule='evenodd' d='M12.392 3.6a3.6 3.6 0 0 1 3.6-3.6c4.41 0 8.401 1.807 11.296 4.662a3.6 3.6 0 1 1-5.056 5.126C20.602 8.18 18.398 7.2 15.992 7.2a3.6 3.6 0 0 1-3.6-3.6Z' fill='url(%23b)'/%3E%3Cpath fill-rule='evenodd' clip-rule='evenodd' d='M0 15.992C0 7.157 7.157 0 15.992 0a3.6 3.6 0 0 1 0 7.2A8.789 8.789 0 0 0 7.2 15.992c0 2.406.981 4.61 2.588 6.24a3.6 3.6 0 0 1-5.126 5.056C1.807 24.393 0 20.402 0 15.992Z' fill='url(%23c)'/%3E%3Cpath fill-rule='evenodd' clip-rule='evenodd' d='M4.661 22.232a3.6 3.6 0 0 1 5.091-.035c1.63 1.606 3.834 2.587 6.24 2.587a3.6 3.6 0 0 1 0 7.2c-4.41 0-8.401-1.807-11.295-4.661a3.6 3.6 0 0 1-.036-5.091Z' fill='url(%23d)'/%3E%3Cpath fill-rule='evenodd' clip-rule='evenodd' d='M28.384 12.392a3.6 3.6 0 0 1 3.6 3.6c0 8.835-7.157 15.992-15.992 15.992a3.6 3.6 0 0 1 0-7.2 8.789 8.789 0 0 0 8.792-8.792 3.6 3.6 0 0 1 3.6-3.6Z' fill='url(%23e)'/%3E%3Cpath fill-rule='evenodd' clip-rule='evenodd' d='M28.385 12.392a3.6 3.6 0 0 1 3.6 3.6v12.392a3.6 3.6 0 0 1-7.2 0V15.992a3.6 3.6 0 0 1 3.6-3.6Z' fill='url(%23f)'/%3E%3Cg clip-path='url(%23g)'%3E%3Cpath fill-rule='evenodd' clip-rule='evenodd' d='M22.232 4.662a3.6 3.6 0 0 1 5.091.035c2.855 2.894 4.662 6.885 4.662 11.295a3.6 3.6 0 0 1-7.2 0c0-2.406-.982-4.61-2.588-6.24a3.6 3.6 0 0 1 .035-5.09Z' fill='url(%23h)'/%3E%3C/g%3E%3Cdefs%3E%3ClinearGradient id='a' x1='26.4' y1='9.6' x2='28.8' y2='15' gradientUnits='userSpaceOnUse'%3E%3Cstop stop-color='%237E22CE'/%3E%3Cstop offset='1' stop-color='%238B5CF6'/%3E%3C/linearGradient%3E%3ClinearGradient id='b' x1='26.8' y1='9.4' x2='17.8' y2='3.6' gradientUnits='userSpaceOnUse'%3E%3Cstop stop-color='%23EF4444'/%3E%3Cstop offset='1' stop-color='%23DC2626'/%3E%3C/linearGradient%3E%3ClinearGradient id='c' x1='3.6' y1='14' x2='5.4' y2='24.8' gradientUnits='userSpaceOnUse'%3E%3Cstop stop-color='%2322C55E'/%3E%3Cstop offset='1' stop-color='%2315803D'/%3E%3C/linearGradient%3E%3ClinearGradient id='d' x1='4.8' y1='22.2' x2='14.4' y2='29.2' gradientUnits='userSpaceOnUse'%3E%3Cstop stop-color='%2394A3B8'/%3E%3Cstop offset='.958' stop-color='%2364748B'/%3E%3Cstop offset='1' stop-color='%2364748B'/%3E%3C/linearGradient%3E%3ClinearGradient id='e' x1='28.4' y1='22.173' x2='22.188' y2='28.384' gradientUnits='userSpaceOnUse'%3E%3Cstop stop-color='%23D97706'/%3E%3Cstop offset='1' stop-color='%23FBBF24'/%3E%3C/linearGradient%3E%3ClinearGradient id='f' x1='29.2' y1='54.4' x2='30.626' y2='54.256' gradientUnits='userSpaceOnUse'%3E%3Cstop stop-color='%23FBBF24'/%3E%3Cstop offset='1' stop-color='%23FBBF24'/%3E%3C/linearGradient%3E%3ClinearGradient id='h' x1='26.4' y1='9.6' x2='28.8' y2='15' gradientUnits='userSpaceOnUse'%3E%3Cstop stop-color='%237E22CE'/%3E%3Cstop offset='1' stop-color='%238B5CF6'/%3E%3C/linearGradient%3E%3CclipPath id='g'%3E%3Cpath fill='%23fff' transform='translate(24.8 12)' d='M0 0h7.2v8H0z'/%3E%3C/clipPath%3E%3C/defs%3E%3C/svg%3E" />
     {{{ headTags }}}
 </head>
 <body>
@@ -73,16 +73,17 @@ const createBreadcrumbs = (convertedTr) => {
         return acc;
     }, []);
 };
-export const generateTestResults = async (writer, store) => {
-    const allTr = await store.allTestResults({ includeHidden: true });
+export const generateTestResults = async (writer, store, trs, filter) => {
+    const allTr = trs.filter((tr) => (filter ? filter(tr) : true));
     let 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.history = (await store.historyByTrId(tr.id)) ?? [];
         convertedTr.retries = await store.retriesByTrId(tr.id);
-        convertedTr.retry = convertedTr.retries.length > 0;
+        convertedTr.retriesCount = convertedTr.retries.length;
+        convertedTr.retry = convertedTr.retriesCount > 0;
         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) => ({
@@ -99,38 +100,133 @@ export const generateTestResults = async (writer, store) => {
     for (const convertedTr of convertedTrs) {
         await writer.writeTestCase(convertedTr);
     }
-    await writer.writeWidget("nav.json", convertedTrs.filter(({ hidden }) => !hidden).map(({ id }) => id));
     return convertedTrs;
 };
-export const generateTree = async (writer, treeName, labels, tests) => {
+export const generateTestCases = async (writer, trs) => {
+    for (const tr of trs) {
+        await writer.writeTestCase(tr);
+    }
+};
+export const generateTestEnvGroups = async (writer, groups) => {
+    for (const group of groups) {
+        const src = join("test-env-groups", `${group.id}.json`);
+        await writer.writeData(src, group);
+    }
+};
+export const generateNav = async (writer, trs, filename = "nav.json") => {
+    await writer.writeWidget(filename, trs.filter(({ hidden }) => !hidden).map(({ id }) => id));
+};
+export const generateTree = async (writer, treeFilename, labels, tests, options) => {
     const visibleTests = tests.filter((test) => !test.hidden);
-    const tree = createTreeByLabels(visibleTests, labels, ({ id, name, status, duration, flaky, start, retries }) => {
-        return {
-            nodeId: id,
-            retry: !!retries?.length,
-            name,
-            status,
-            duration,
-            flaky,
-            start,
-        };
-    }, undefined, (group, leaf) => {
-        incrementStatistic(group.statistic, leaf.status);
-    });
+    const { appendTitlePath } = options || {};
+    let tree;
+    if (labels.length === 0) {
+        tree = buildTreeByTitlePath(visibleTests);
+    }
+    else if (appendTitlePath && labels.length) {
+        tree = buildTreeByLabelsAndTitlePathCombined(visibleTests, labels);
+    }
+    else {
+        tree = buildTreeByLabels(visibleTests, labels);
+    }
     filterTree(tree, (leaf) => !leaf.hidden);
     sortTree(tree, nullsLast(compareBy("start", ordinal())));
     transformTree(tree, (leaf, idx) => ({ ...leaf, groupOrder: idx + 1 }));
-    await writer.writeWidget(`${treeName}.json`, tree);
+    await writer.writeWidget(treeFilename, tree);
+};
+const buildTreeByLabels = (tests, labels) => {
+    return createTreeByLabels(tests, labels, leafFactory, undefined, (group, leaf) => incrementStatistic(group.statistic, leaf.status));
+};
+const buildTreeByTitlePath = (tests) => {
+    const testsWithTitlePath = [];
+    const testsWithoutTitlePath = [];
+    for (const test of tests) {
+        if (Array.isArray(test.titlePath) && test.titlePath.length > 0) {
+            testsWithTitlePath.push(test);
+        }
+        else {
+            testsWithoutTitlePath.push(test);
+        }
+    }
+    const treeByTitlePath = createTreeByTitlePath(testsWithTitlePath, leafFactory, undefined, (group, leaf) => incrementStatistic(group.statistic, leaf.status));
+    if (!testsWithoutTitlePath.length) {
+        return treeByTitlePath;
+    }
+    const defaultLabels = preciseTreeLabels(["parentSuite", "suite", "subSuite"], testsWithoutTitlePath, ({ labels }) => labels.map(({ name }) => name));
+    let treeByDefaultLabels = null;
+    if (defaultLabels.length) {
+        treeByDefaultLabels = createTreeByLabelsAndTitlePath(testsWithoutTitlePath, defaultLabels, leafFactory, undefined, (group, leaf) => incrementStatistic(group.statistic, leaf.status));
+    }
+    else {
+        for (const test of testsWithoutTitlePath) {
+            const leaf = leafFactory(test);
+            treeByTitlePath.leavesById[leaf.nodeId] = leaf;
+            if (!treeByTitlePath.root.leaves) {
+                treeByTitlePath.root.leaves = [];
+            }
+            treeByTitlePath.root.leaves.push(leaf.nodeId);
+        }
+        return treeByTitlePath;
+    }
+    const mergedLeavesById = {
+        ...treeByTitlePath.leavesById,
+        ...treeByDefaultLabels.leavesById,
+    };
+    const mergedGroupsById = {
+        ...treeByTitlePath.groupsById,
+        ...treeByDefaultLabels.groupsById,
+    };
+    const mergedRootLeaves = Array.from(new Set([...(treeByTitlePath.root.leaves ?? []), ...(treeByDefaultLabels.root.leaves ?? [])]));
+    const mergedRootGroups = Array.from(new Set([...(treeByTitlePath.root.groups ?? []), ...(treeByDefaultLabels.root.groups ?? [])]));
+    return {
+        root: {
+            leaves: mergedRootLeaves,
+            groups: mergedRootGroups,
+        },
+        leavesById: mergedLeavesById,
+        groupsById: mergedGroupsById,
+    };
 };
+const buildTreeByLabelsAndTitlePathCombined = (tests, labels) => createTreeByLabelsAndTitlePath(tests, labels, leafFactory, undefined, (group, leaf) => incrementStatistic(group.statistic, leaf.status));
+const leafFactory = ({ id, name, status, duration, flaky, start, transition, retry, retriesCount, }) => ({
+    nodeId: id,
+    name,
+    status,
+    duration,
+    flaky,
+    start,
+    retry,
+    retriesCount,
+    transition,
+});
 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 generateEnvirontmentsList = async (writer, store) => {
+    const environments = await store.allEnvironments();
+    await writer.writeWidget("environments.json", environments);
 };
-export const generatePieChart = async (writer, statistic) => {
-    const chartData = getChartData(statistic);
-    await writer.writeWidget("allure_pie_chart.json", chartData);
+export const generateVariables = async (writer, store) => {
+    const reportVariables = await store.allVariables();
+    const environments = await store.allEnvironments();
+    await writer.writeWidget("variables.json", reportVariables);
+    for (const env of environments) {
+        const envVariables = await store.envVariables(env);
+        await writer.writeWidget(join(env, "variables.json"), envVariables);
+    }
+};
+export const generateStatistic = async (writer, data) => {
+    const { stats, statsByEnv, envs } = data;
+    await writer.writeWidget("statistic.json", stats);
+    await writer.writeWidget("pie_chart.json", getPieChartValues(stats));
+    for (const env of envs) {
+        const envStats = statsByEnv.get(env);
+        if (!envStats) {
+            continue;
+        }
+        await writer.writeWidget(join(env, "statistic.json"), envStats);
+        await writer.writeWidget(join(env, "pie_chart.json"), envStats);
+    }
 };
 export const generateAttachmentsFiles = async (writer, attachmentLinks, contentFunction) => {
     const result = new Map();
@@ -157,12 +253,36 @@ export const generateHistoryDataPoints = async (writer, store) => {
     }
     return result;
 };
+export const generateGlobals = async (writer, payload) => {
+    const { globalExitCode, globalAttachments = [], globalErrors = [], contentFunction } = payload;
+    const globals = {
+        errors: globalErrors,
+        attachments: [],
+    };
+    if (globalExitCode) {
+        globals.exitCode = globalExitCode;
+    }
+    for (const attachment of globalAttachments) {
+        const src = `${attachment.id}${attachment.ext}`;
+        const content = await contentFunction(attachment.id);
+        if (!content) {
+            continue;
+        }
+        await writer.writeAttachment(src, content);
+        globals.attachments.push(attachment);
+    }
+    await writer.writeWidget("globals.json", globals);
+};
+export const generateQualityGateResults = async (writer, qualityGateResults = []) => {
+    await writer.writeWidget("quality-gate.json", qualityGateResults);
+};
 export const generateStaticFiles = async (payload) => {
-    const { reportName = "Allure Report", reportLanguage = "en", singleFile, logo = "", theme = "light", groupBy, reportFiles, reportDataFiles, reportUuid, allureVersion, } = payload;
+    const { id, reportName = "Allure Report", reportLanguage = "en", singleFile, logo = "", theme = "auto", groupBy, reportFiles, reportDataFiles, reportUuid, allureVersion, layout = "base", defaultSection = "", ci, } = payload;
     const compile = Handlebars.compile(template);
     const manifest = await readTemplateManifest(payload.singleFile);
     const headTags = [];
     const bodyTags = [];
+    const sections = ["charts", "timeline"];
     if (!payload.singleFile) {
         for (const key in manifest) {
             const fileName = manifest[key];
@@ -186,28 +306,52 @@ export const generateStaticFiles = async (payload) => {
     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 mainJsContent = await readFile(mainJsSource);
+        bodyTags.push(createScriptTag(`data:text/javascript;base64,${mainJsContent.toString("base64")}`));
     }
+    const now = Date.now();
     const reportOptions = {
+        id,
         reportName,
         logo,
         theme,
         reportLanguage,
-        createdAt: Date.now(),
+        createdAt: now,
         reportUuid,
-        groupBy: groupBy?.length ? groupBy : ["parentSuite", "suite", "subSuite"],
-    };
-    const html = compile({
-        headTags: headTags.join("\n"),
-        bodyTags: bodyTags.join("\n"),
-        reportFilesScript: createReportDataScript(reportDataFiles),
-        reportOptions: JSON.stringify(reportOptions),
-        analyticsEnable: true,
+        groupBy: groupBy?.length ? groupBy : [],
+        cacheKey: now.toString(),
+        ci,
+        layout,
         allureVersion,
-        reportUuid,
-        reportName,
-        singleFile: payload.singleFile,
-    });
-    await reportFiles.addFile("index.html", Buffer.from(html, "utf8"));
+        sections,
+        defaultSection,
+    };
+    try {
+        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"));
+    }
+    catch (err) {
+        if (err instanceof RangeError) {
+            console.error("The report is too large to be generated in the single file mode!");
+            process.exit(1);
+        }
+        throw err;
+    }
+};
+export const generateAllCharts = async (writer, store, options, context) => {
+    const { charts = defaultChartsConfig } = options;
+    const generatedChartsData = await generateCharts(charts, store, context.reportName, randomUUID);
+    if (Object.keys(generatedChartsData.general).length > 0) {
+        await writer.writeWidget("charts.json", generatedChartsData);
+    }
 };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { AllureAwesomePlugin } from "./plugin.js";
-export default AllureAwesomePlugin;
+export type { AwesomePluginOptions } from "./model.js";
+export { AwesomePlugin as default } from "./plugin.js";

package/dist/index.js

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

package/dist/model.d.ts

@@ -1,15 +1,24 @@
-export type AllureAwesomeOptions = {
+import type { ChartOptions } from "@allurereport/charts-api";
+import type { CiDescriptor, EnvironmentsConfig, TestResult } from "@allurereport/core-api";
+export type AwesomeOptions = {
     reportName?: string;
     singleFile?: boolean;
     logo?: string;
-    theme?: "light" | "dark";
-    reportLanguage?: "en" | "ru";
+    theme?: "light" | "dark" | "auto";
+    reportLanguage?: "en";
     groupBy?: string[];
-    ci?: {
-        type: "github" | "jenkins";
-        url: string;
-        name: string;
+    layout?: "base" | "split";
+    environments?: Record<string, EnvironmentsConfig>;
+    ci?: CiDescriptor;
+    filter?: (testResult: TestResult) => boolean;
+    charts?: ChartOptions[];
+    timeline?: {
+        minDuration?: number;
     };
+    sections?: string[];
+    defaultSection?: string;
+    publish?: boolean;
+    appendTitlePath?: boolean;
 };
 export type TemplateManifest = Record<string, string>;
-export type AllureAwesomePluginOptions = AllureAwesomeOptions;
+export type AwesomePluginOptions = AwesomeOptions;

package/dist/plugin.d.ts

@@ -1,10 +1,11 @@
-import type { AllureStore, Plugin, PluginContext } from "@allurereport/plugin-api";
-import type { AllureAwesomePluginOptions } from "./model.js";
-export declare class AllureAwesomePlugin implements Plugin {
+import { type AllureStore, type Plugin, type PluginContext, type PluginSummary } from "@allurereport/plugin-api";
+import type { AwesomePluginOptions } from "./model.js";
+export declare class AwesomePlugin implements Plugin {
     #private;
-    readonly options: AllureAwesomePluginOptions;
-    constructor(options?: AllureAwesomePluginOptions);
+    readonly options: AwesomePluginOptions;
+    constructor(options?: AwesomePluginOptions);
     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

@@ -9,62 +9,133 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     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;
+var _AwesomePlugin_writer, _AwesomePlugin_generate;
+import { getWorstStatus } from "@allurereport/core-api";
+import { convertToSummaryTestResult, } from "@allurereport/plugin-api";
 import { preciseTreeLabels } from "@allurereport/plugin-api";
-import { generateAttachmentsFiles, generateEnvironmentJson, generateHistoryDataPoints, generatePieChart, generateStaticFiles, generateStatistic, generateTestResults, generateTree, } from "./generators.js";
+import { join } from "node:path";
+import { filterEnv } from "./environments.js";
+import { generateTimeline } from "./generateTimeline.js";
+import { generateAllCharts, generateAttachmentsFiles, generateEnvironmentJson, generateEnvirontmentsList, generateGlobals, generateHistoryDataPoints, generateNav, generateQualityGateResults, generateStaticFiles, generateStatistic, generateTestCases, generateTestEnvGroups, generateTestResults, generateTree, generateVariables, } from "./generators.js";
 import { InMemoryReportDataWriter, ReportFileDataWriter } from "./writer.js";
-export class AllureAwesomePlugin {
+export class AwesomePlugin {
     constructor(options = {}) {
         this.options = options;
-        _AllureAwesomePlugin_writer.set(this, void 0);
-        _AllureAwesomePlugin_generate.set(this, async (context, store) => {
-            const { singleFile, groupBy = [] } = this.options ?? {};
+        _AwesomePlugin_writer.set(this, void 0);
+        _AwesomePlugin_generate.set(this, async (context, store) => {
+            const { singleFile, groupBy = [], filter, appendTitlePath } = this.options ?? {};
             const environmentItems = await store.metadataByKey("allure_environment");
-            const statistic = await store.testsStatistic();
+            const reportEnvironments = await store.allEnvironments();
             const attachments = await store.allAttachments();
-            await generateStatistic(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), statistic);
-            await generatePieChart(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), statistic);
-            const convertedTrs = await generateTestResults(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), store);
-            const treeLabels = preciseTreeLabels(!groupBy.length ? ["parentSuite", "suite", "subSuite"] : groupBy, convertedTrs, ({ labels }) => labels.map(({ name }) => name));
-            await generateTree(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), "tree", treeLabels, convertedTrs);
-            await generateHistoryDataPoints(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), store);
+            const allTrs = await store.allTestResults({ includeHidden: true });
+            const statistics = await store.testsStatistic(filter);
+            const environments = await store.allEnvironments();
+            const envStatistics = new Map();
+            const allTestEnvGroups = await store.allTestEnvGroups();
+            const globalAttachments = await store.allGlobalAttachments();
+            const globalExitCode = await store.globalExitCode();
+            const globalErrors = await store.allGlobalErrors();
+            const qualityGateResults = await store.qualityGateResults();
+            for (const env of environments) {
+                envStatistics.set(env, await store.testsStatistic(filterEnv(env, filter)));
+            }
+            await generateStatistic(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), {
+                stats: statistics,
+                statsByEnv: envStatistics,
+                envs: environments,
+            });
+            await generateAllCharts(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, this.options, context);
+            await generateTimeline(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, this.options);
+            const convertedTrs = await generateTestResults(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, allTrs, this.options.filter);
+            const hasGroupBy = groupBy.length > 0;
+            const treeLabels = hasGroupBy
+                ? preciseTreeLabels(groupBy, convertedTrs, ({ labels }) => labels.map(({ name }) => name))
+                : [];
+            await generateHistoryDataPoints(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store);
+            await generateTestCases(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), convertedTrs);
+            await generateTree(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), "tree.json", treeLabels, convertedTrs, { appendTitlePath });
+            await generateNav(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), convertedTrs, "nav.json");
+            await generateTestEnvGroups(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), allTestEnvGroups);
+            for (const reportEnvironment of reportEnvironments) {
+                const envConvertedTrs = convertedTrs.filter(({ environment }) => environment === reportEnvironment);
+                await generateTree(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), join(reportEnvironment, "tree.json"), treeLabels, envConvertedTrs, {
+                    appendTitlePath,
+                });
+                await generateNav(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), envConvertedTrs, join(reportEnvironment, "nav.json"));
+            }
+            await generateEnvirontmentsList(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store);
+            await generateVariables(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store);
             if (environmentItems?.length) {
-                await generateEnvironmentJson(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), environmentItems);
+                await generateEnvironmentJson(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), environmentItems);
             }
             if (attachments?.length) {
-                await generateAttachmentsFiles(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), attachments, (id) => store.attachmentContentById(id));
+                await generateAttachmentsFiles(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), attachments, (id) => store.attachmentContentById(id));
             }
-            const reportDataFiles = singleFile ? __classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f").reportFiles() : [];
+            await generateQualityGateResults(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), qualityGateResults);
+            await generateGlobals(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), {
+                globalAttachments,
+                globalErrors,
+                globalExitCode,
+                contentFunction: (id) => store.attachmentContentById(id),
+            });
+            const reportDataFiles = singleFile ? __classPrivateFieldGet(this, _AwesomePlugin_writer, "f").reportFiles() : [];
             await generateStaticFiles({
                 ...this.options,
+                id: context.id,
                 allureVersion: context.allureVersion,
                 reportFiles: context.reportFiles,
-                reportDataFiles,
                 reportUuid: context.reportUuid,
                 reportName: context.reportName,
+                ci: context.ci,
+                reportDataFiles,
             });
         });
         this.start = async (context) => {
             const { singleFile } = this.options;
             if (singleFile) {
-                __classPrivateFieldSet(this, _AllureAwesomePlugin_writer, new InMemoryReportDataWriter(), "f");
+                __classPrivateFieldSet(this, _AwesomePlugin_writer, new InMemoryReportDataWriter(), "f");
                 return;
             }
-            __classPrivateFieldSet(this, _AllureAwesomePlugin_writer, new ReportFileDataWriter(context.reportFiles), "f");
+            __classPrivateFieldSet(this, _AwesomePlugin_writer, new ReportFileDataWriter(context.reportFiles), "f");
             await Promise.resolve();
         };
         this.update = async (context, store) => {
-            if (!__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f")) {
+            if (!__classPrivateFieldGet(this, _AwesomePlugin_writer, "f")) {
                 throw new Error("call start first");
             }
-            await __classPrivateFieldGet(this, _AllureAwesomePlugin_generate, "f").call(this, context, store);
+            await __classPrivateFieldGet(this, _AwesomePlugin_generate, "f").call(this, context, store);
         };
         this.done = async (context, store) => {
-            if (!__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f")) {
+            if (!__classPrivateFieldGet(this, _AwesomePlugin_writer, "f")) {
                 throw new Error("call start first");
             }
-            await __classPrivateFieldGet(this, _AllureAwesomePlugin_generate, "f").call(this, context, store);
+            await __classPrivateFieldGet(this, _AwesomePlugin_generate, "f").call(this, context, store);
+        };
+    }
+    async info(context, store) {
+        const allTrs = (await store.allTestResults()).filter((tr) => this.options.filter ? this.options.filter(tr) : true);
+        const newTrs = await store.allNewTestResults();
+        const retryTrs = allTrs.filter((tr) => !!tr?.retries?.length);
+        const flakyTrs = allTrs.filter((tr) => !!tr?.flaky);
+        const duration = allTrs.reduce((acc, { duration: trDuration = 0 }) => acc + trDuration, 0);
+        const worstStatus = getWorstStatus(allTrs.map(({ status }) => status));
+        const createdAt = allTrs.reduce((acc, { stop }) => Math.max(acc, stop || 0), 0);
+        return {
+            name: this.options.reportName || context.reportName,
+            stats: await store.testsStatistic(this.options.filter),
+            status: worstStatus ?? "passed",
+            duration,
+            createdAt,
+            plugin: "Awesome",
+            newTests: newTrs.map(convertToSummaryTestResult),
+            flakyTests: flakyTrs.map(convertToSummaryTestResult),
+            retryTests: retryTrs.map(convertToSummaryTestResult),
+            meta: {
+                reportId: context.reportUuid,
+                singleFile: this.options.singleFile ?? false,
+                withTestResultsLinks: true,
+            },
         };
     }
 }
-_AllureAwesomePlugin_writer = new WeakMap(), _AllureAwesomePlugin_generate = new WeakMap();
+_AwesomePlugin_writer = new WeakMap(), _AwesomePlugin_generate = new WeakMap();

package/dist/writer.d.ts

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

package/dist/writer.js

@@ -5,7 +5,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _InMemoryReportDataWriter_data;
 import { mkdir, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { resolve } from "node:path";
 import { join as joinPosix } from "node:path/posix";
 export class FileSystemReportDataWriter {
     constructor(output) {
@@ -56,7 +56,10 @@ export class InMemoryReportDataWriter {
         }
     }
     reportFiles() {
-        return Object.keys(__classPrivateFieldGet(this, _InMemoryReportDataWriter_data, "f")).map((key) => ({ name: key, value: __classPrivateFieldGet(this, _InMemoryReportDataWriter_data, "f")[key].toString("base64") }));
+        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();
@@ -75,7 +78,7 @@ export class ReportFileDataWriter {
         if (!contentBuffer) {
             return;
         }
-        await this.reportFiles.addFile(join("data", "attachments", source), contentBuffer);
+        await this.reportFiles.addFile(joinPosix("data", "attachments", source), contentBuffer);
     }
     async writeTestCase(test) {
         await this.reportFiles.addFile(joinPosix("data", "test-results", `${test.id}.json`), Buffer.from(JSON.stringify(test), "utf8"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-awesome",
-  "version": "3.0.0-beta.9",
+  "version": "3.0.0",
   "description": "Allure Awesome Plugin – brand new HTML report with modern design and new features",
   "keywords": [
     "allure",
@@ -30,10 +30,11 @@
     "test": "rimraf ./out && vitest run"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.0.0-beta.9",
-    "@allurereport/plugin-api": "3.0.0-beta.9",
-    "@allurereport/web-awesome": "3.0.0-beta.9",
-    "@allurereport/web-commons": "3.0.0-beta.9",
+    "@allurereport/charts-api": "3.0.0",
+    "@allurereport/core-api": "3.0.0",
+    "@allurereport/plugin-api": "3.0.0",
+    "@allurereport/web-awesome": "3.0.0",
+    "@allurereport/web-commons": "3.0.0",
     "d3-shape": "^3.2.0",
     "handlebars": "^4.7.8"
   },
@@ -44,8 +45,8 @@
     "@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",
+    "@vitest/runner": "^2.1.9",
+    "allure-vitest": "^3.3.3",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.29.1",
@@ -55,6 +56,6 @@
     "eslint-plugin-prefer-arrow": "^1.2.3",
     "rimraf": "^6.0.1",
     "typescript": "^5.6.3",
-    "vitest": "^2.1.8"
+    "vitest": "^2.1.9"
   }
 }

package/dist/charts.d.ts

@@ -1,14 +0,0 @@
-import type { Statistic, TestStatus } from "@allurereport/core-api";
-import type { 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 const getPercentage: (value: number, total: number) => number;
-export declare const getChartData: (stats: Statistic) => TestResultChartData;

package/dist/charts.js

@@ -1,26 +0,0 @@
-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 getChartData = (stats) => {
-    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 {
-        slices,
-        percentage,
-    };
-};