@allurereport/plugin-classic 3.0.0-beta.9 → 3.0.1

package/dist/categories.d.ts

@@ -1,8 +1,8 @@
 import type { TestStatus } from "@allurereport/core-api";
-import type { AllureAwesomeCategory } from "./model.js";
-export declare const matchCategories: (categories: AllureAwesomeCategory[], result: {
+import type { ClassicCategory } from "./model.js";
+export declare const matchCategories: (categories: ClassicCategory[], result: {
     message?: string;
     trace?: string;
     status: TestStatus;
     flaky: boolean;
-}) => AllureAwesomeCategory[];
+}) => ClassicCategory[];

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 { ClassicFixtureResult, ClassicTestResult, ClassicTestStepResult } from "@allurereport/web-classic";
+export declare const convertTestResult: (tr: TestResult) => ClassicTestResult;
+export declare const convertTestStepResult: (tsr: TestStepResult) => ClassicTestStepResult;
+export declare const convertFixtureResult: (fr: TestFixtureResult) => ClassicFixtureResult;

package/dist/converters.js

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

package/dist/generators.d.ts

@@ -1,21 +1,21 @@
 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 { ClassicTestResult } from "@allurereport/web-classic";
+import type { ClassicOptions, TemplateManifest } from "./model.js";
+import type { ClassicDataWriter, 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: ClassicDataWriter, store: AllureStore) => Promise<ClassicTestResult[]>;
+export declare const generateTree: (writer: ClassicDataWriter, treeName: string, labels: string[], tests: ClassicTestResult[]) => Promise<void>;
+export declare const generateEnvironmentJson: (writer: ClassicDataWriter, env: EnvironmentItem[]) => Promise<void>;
+export declare const generateStatistic: (writer: ClassicDataWriter, statistic: Statistic) => Promise<void>;
+export declare const generatePieChart: (writer: ClassicDataWriter, statistic: Statistic) => Promise<void>;
+export declare const generateAttachmentsFiles: (writer: ClassicDataWriter, attachmentLinks: AttachmentLink[], contentFunction: (id: string) => Promise<ResultFile | undefined>) => Promise<Map<string, string> | undefined>;
+export declare const generateHistoryDataPoints: (writer: ClassicDataWriter, store: AllureStore) => Promise<Map<string, string>>;
+export declare const generateStaticFiles: (payload: ClassicOptions & {
     allureVersion: string;
     reportFiles: ReportFiles;
     reportDataFiles: ReportFile[];
     reportUuid: string;
     reportName: string;
 }) => Promise<void>;
-export declare const generateTreeByCategories: (writer: AllureAwesomeDataWriter, treeName: string, tests: AllureAwesomeTestResult[]) => Promise<void>;
+export declare const generateTreeByCategories: (writer: ClassicDataWriter, treeName: string, tests: ClassicTestResult[]) => Promise<void>;

package/dist/generators.js

@@ -1,12 +1,11 @@
-import { compareBy, incrementStatistic, nullsLast, ordinal, } from "@allurereport/core-api";
+import { compareBy, createBaseUrlScript, createFontLinkTag, createReportDataScript, createScriptTag, createStylesLinkTag, incrementStatistic, nullsLast, ordinal, } from "@allurereport/core-api";
 import { createTreeByCategories, createTreeByLabels, filterTree, sortTree, transformTree, } from "@allurereport/plugin-api";
-import { createBaseUrlScript, createFontLinkTag, createReportDataScript, createScriptTag, createStylesLinkTag, } from "@allurereport/web-commons";
+import { getPieChartValues } 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 { matchCategories } from "./categories.js";
-import { getChartData } from "./charts.js";
 import { convertFixtureResult, convertTestResult } from "./converters.js";
 const require = createRequire(import.meta.url);
 const template = `<!DOCTYPE html>
@@ -89,7 +88,7 @@ export const generateTestResults = async (writer, store) => {
             flaky,
         });
         convertedTr.categories = matchedCategories;
-        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.setup = convertedTrFixtures.filter((f) => f.type === "before");
@@ -113,14 +112,17 @@ export const generateTestResults = async (writer, store) => {
 };
 export const generateTree = async (writer, treeName, labels, tests) => {
     const visibleTests = tests.filter((test) => !test.hidden);
-    const tree = createTreeByLabels(visibleTests, labels, ({ id, name, status, duration, flaky, start, retries }) => {
+    const tree = createTreeByLabels(visibleTests, labels, ({ id, name, status, duration, flaky, transition, start, retries }) => {
+        const retriesCount = retries?.length ?? 0;
         return {
             nodeId: id,
-            retry: !!retries?.length,
+            retry: Boolean(retriesCount),
+            retriesCount,
             name,
             status,
             duration,
             flaky,
+            transition,
             start,
         };
     }, undefined, (group, leaf) => {
@@ -138,7 +140,7 @@ export const generateStatistic = async (writer, statistic) => {
     await writer.writeWidget("allure_statistic.json", statistic);
 };
 export const generatePieChart = async (writer, statistic) => {
-    const chartData = getChartData(statistic);
+    const chartData = getPieChartValues(statistic);
     await writer.writeWidget("allure_pie_chart.json", chartData);
 };
 export const generateAttachmentsFiles = async (writer, attachmentLinks, contentFunction) => {
@@ -167,7 +169,7 @@ export const generateHistoryDataPoints = async (writer, store) => {
     return result;
 };
 export const generateStaticFiles = async (payload) => {
-    const { reportName = "Allure Report", reportLanguage = "en", singleFile, logo = "", theme = "light", groupBy, reportFiles, reportDataFiles, reportUuid, allureVersion, } = payload;
+    const { reportName = "Allure Report", reportLanguage = "en", singleFile, logo = "", theme = "auto", groupBy, reportFiles, reportDataFiles, reportUuid, allureVersion, } = payload;
     const compile = Handlebars.compile(template);
     const manifest = await readTemplateManifest(payload.singleFile);
     const headTags = [];
@@ -198,38 +200,53 @@ export const generateStaticFiles = async (payload) => {
         const mainJsContentBuffer = await readFile(mainJsSource);
         bodyTags.push(createScriptTag(`data:text/javascript;base64,${mainJsContentBuffer.toString("base64")}`));
     }
+    const now = Date.now();
     const reportOptions = {
         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,
         allureVersion,
-        reportUuid,
-        reportName,
-        singleFile: payload.singleFile,
-    });
-    await reportFiles.addFile("index.html", Buffer.from(html, "utf8"));
+        cacheKey: now.toString(),
+    };
+    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 generateTreeByCategories = async (writer, treeName, tests) => {
     const visibleTests = tests.filter((test) => !test.hidden);
-    const tree = createTreeByCategories(visibleTests, ({ id, name, status, duration, flaky, start, retries }) => {
+    const tree = createTreeByCategories(visibleTests, ({ id, name, status, duration, flaky, transition, start, retries }) => {
+        const retriesCount = retries?.length ?? 0;
         return {
             nodeId: id,
-            retry: !!retries?.length,
+            retry: Boolean(retriesCount),
+            retriesCount,
             name,
             status,
             duration,
             flaky,
+            transition,
             start,
         };
     }, undefined, (group, leaf) => {

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/model.d.ts

@@ -1,20 +1,21 @@
-import type { TestStatus } from "@allurereport/core-api";
-export type AllureAwesomeOptions = {
+import type { TestResult, TestStatus } from "@allurereport/core-api";
+export type ClassicOptions = {
     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;
     };
+    filter?: (tr: TestResult) => boolean;
 };
 export type TemplateManifest = Record<string, string>;
-export type AllureAwesomePluginOptions = AllureAwesomeOptions;
-export interface AllureAwesomeCategory {
+export type ClassicPluginOptions = ClassicOptions;
+export interface ClassicCategory {
     name: string;
     description?: string;
     descriptionHtml?: string;

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 { ClassicPluginOptions } from "./model.js";
+export declare class ClassicPlugin implements Plugin {
     #private;
-    readonly options: AllureAwesomePluginOptions;
-    constructor(options?: AllureAwesomePluginOptions);
+    readonly options: ClassicPluginOptions;
+    constructor(options?: ClassicPluginOptions);
     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,37 +9,39 @@ 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 _ClassicPlugin_writer, _ClassicPlugin_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, generateTreeByCategories, } from "./generators.js";
 import { InMemoryReportDataWriter, ReportFileDataWriter } from "./writer.js";
-export class AllureAwesomePlugin {
+export class ClassicPlugin {
     constructor(options = {}) {
         this.options = options;
-        _AllureAwesomePlugin_writer.set(this, void 0);
-        _AllureAwesomePlugin_generate.set(this, async (context, store) => {
+        _ClassicPlugin_writer.set(this, void 0);
+        _ClassicPlugin_generate.set(this, async (context, store) => {
             const { singleFile, groupBy = [] } = this.options ?? {};
             const environmentItems = await store.metadataByKey("allure_environment");
             const statistic = await store.testsStatistic();
             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);
+            await generateStatistic(__classPrivateFieldGet(this, _ClassicPlugin_writer, "f"), statistic);
+            await generatePieChart(__classPrivateFieldGet(this, _ClassicPlugin_writer, "f"), statistic);
+            const convertedTrs = await generateTestResults(__classPrivateFieldGet(this, _ClassicPlugin_writer, "f"), store);
             const treeLabels = preciseTreeLabels(!groupBy.length ? ["parentSuite", "suite", "subSuite"] : groupBy, convertedTrs, ({ labels }) => labels.map(({ name }) => name));
             const behaviorLabels = preciseTreeLabels(!groupBy.length ? ["epic", "feature", "story"] : groupBy, convertedTrs, ({ labels }) => labels.map(({ name }) => name));
             const packagesLabels = preciseTreeLabels(!groupBy.length ? ["package"] : groupBy, convertedTrs, ({ labels }) => labels.map(({ name }) => name));
-            await generateTreeByCategories(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), "categories", convertedTrs);
-            await generateTree(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), "tree", treeLabels, convertedTrs);
-            await generateTree(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), "behaviors", behaviorLabels, convertedTrs);
-            await generateTree(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), "packages", packagesLabels, convertedTrs);
-            await generateHistoryDataPoints(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), store);
+            await generateTreeByCategories(__classPrivateFieldGet(this, _ClassicPlugin_writer, "f"), "categories", convertedTrs);
+            await generateTree(__classPrivateFieldGet(this, _ClassicPlugin_writer, "f"), "tree", treeLabels, convertedTrs);
+            await generateTree(__classPrivateFieldGet(this, _ClassicPlugin_writer, "f"), "behaviors", behaviorLabels, convertedTrs);
+            await generateTree(__classPrivateFieldGet(this, _ClassicPlugin_writer, "f"), "packages", packagesLabels, convertedTrs);
+            await generateHistoryDataPoints(__classPrivateFieldGet(this, _ClassicPlugin_writer, "f"), store);
             if (environmentItems?.length) {
-                await generateEnvironmentJson(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), environmentItems);
+                await generateEnvironmentJson(__classPrivateFieldGet(this, _ClassicPlugin_writer, "f"), environmentItems);
             }
             if (attachments?.length) {
-                await generateAttachmentsFiles(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), attachments, (id) => store.attachmentContentById(id));
+                await generateAttachmentsFiles(__classPrivateFieldGet(this, _ClassicPlugin_writer, "f"), attachments, (id) => store.attachmentContentById(id));
             }
-            const reportDataFiles = singleFile ? __classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f").reportFiles() : [];
+            const reportDataFiles = singleFile ? __classPrivateFieldGet(this, _ClassicPlugin_writer, "f").reportFiles() : [];
             await generateStaticFiles({
                 ...this.options,
                 allureVersion: context.allureVersion,
@@ -52,24 +54,49 @@ export class AllureAwesomePlugin {
         this.start = async (context) => {
             const { singleFile } = this.options;
             if (singleFile) {
-                __classPrivateFieldSet(this, _AllureAwesomePlugin_writer, new InMemoryReportDataWriter(), "f");
+                __classPrivateFieldSet(this, _ClassicPlugin_writer, new InMemoryReportDataWriter(), "f");
                 return;
             }
-            __classPrivateFieldSet(this, _AllureAwesomePlugin_writer, new ReportFileDataWriter(context.reportFiles), "f");
+            __classPrivateFieldSet(this, _ClassicPlugin_writer, new ReportFileDataWriter(context.reportFiles), "f");
             await Promise.resolve();
         };
         this.update = async (context, store) => {
-            if (!__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f")) {
+            if (!__classPrivateFieldGet(this, _ClassicPlugin_writer, "f")) {
                 throw new Error("call start first");
             }
-            await __classPrivateFieldGet(this, _AllureAwesomePlugin_generate, "f").call(this, context, store);
+            await __classPrivateFieldGet(this, _ClassicPlugin_generate, "f").call(this, context, store);
         };
         this.done = async (context, store) => {
-            if (!__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f")) {
+            if (!__classPrivateFieldGet(this, _ClassicPlugin_writer, "f")) {
                 throw new Error("call start first");
             }
-            await __classPrivateFieldGet(this, _AllureAwesomePlugin_generate, "f").call(this, context, store);
+            await __classPrivateFieldGet(this, _ClassicPlugin_generate, "f").call(this, context, store);
+        };
+    }
+    async info(context, store) {
+        const allTrs = (await store.allTestResults()).filter(this.options.filter ? this.options.filter : () => 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",
+            createdAt,
+            duration,
+            plugin: "Classic",
+            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();
+_ClassicPlugin_writer = new WeakMap(), _ClassicPlugin_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 ClassicDataWriter {
     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 ClassicDataWriter {
     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 ClassicDataWriter {
     #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 ClassicDataWriter {
     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

@@ -6,6 +6,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _InMemoryReportDataWriter_data;
 import { mkdir, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import { join as joinPosix } from "node:path/posix";
 export class FileSystemReportDataWriter {
     constructor(output) {
         this.output = output;
@@ -55,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();
@@ -64,19 +68,19 @@ export class ReportFileDataWriter {
         this.reportFiles = reportFiles;
     }
     async writeData(fileName, data) {
-        await this.reportFiles.addFile(join("data", fileName), Buffer.from(JSON.stringify(data), "utf-8"));
+        await this.reportFiles.addFile(joinPosix("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"));
+        await this.reportFiles.addFile(joinPosix("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);
+        await this.reportFiles.addFile(joinPosix("data", "attachments", source), contentBuffer);
     }
     async writeTestCase(test) {
-        await this.reportFiles.addFile(join("data", "test-results", `${test.id}.json`), Buffer.from(JSON.stringify(test), "utf8"));
+        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-classic",
-  "version": "3.0.0-beta.9",
+  "version": "3.0.1",
   "description": "The classic version of Allure HTML report",
   "keywords": [
     "allure",
@@ -30,11 +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-classic": "3.0.0-beta.9",
-    "@allurereport/web-commons": "3.0.0-beta.9",
+    "@allurereport/core-api": "3.0.1",
+    "@allurereport/plugin-api": "3.0.1",
+    "@allurereport/web-awesome": "3.0.1",
+    "@allurereport/web-classic": "3.0.1",
+    "@allurereport/web-commons": "3.0.1",
     "d3-shape": "^3.2.0",
     "handlebars": "^4.7.8"
   },
@@ -45,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",
@@ -56,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,
-    };
-};