@allurereport/web-commons 3.0.0-beta.13 → 3.0.0-beta.15

package/dist/attachments.js

@@ -72,19 +72,40 @@ export const attachmentType = (type) => {
                 icon: "file",
             };
         case "text/xml":
-        case "application/xml":
-        case "application/json":
         case "text/json":
         case "text/yaml":
-        case "application/yaml":
-        case "application/x-yaml":
+        case "text/javascript":
+        case "text/typescript":
+        case "text/ruby":
+        case "text/python":
+        case "text/php":
+        case "text/java":
+        case "text/csharp":
+        case "text/cpp":
+        case "text/c":
+        case "text/go":
+        case "text/rust":
+        case "text/swift":
+        case "text/kotlin":
+        case "text/scala":
+        case "text/perl":
+        case "text/r":
+        case "text/dart":
+        case "text/lua":
+        case "text/haskell":
+        case "text/sql":
         case "text/x-yaml":
         case "text/css":
+        case "application/yaml":
+        case "application/x-yaml":
+        case "application/xml":
+        case "application/json":
             return {
                 type: "code",
                 icon: "file",
             };
         case "text/plain":
+        case "text/markdown":
         case "text/*":
             return {
                 type: "text",

package/dist/charts/getPieChart.d.ts

@@ -0,0 +1,10 @@
+import type { Statistic, TestStatus } from "@allurereport/core-api";
+export type TestResultSlice = {
+    status: TestStatus;
+    count: number;
+};
+export type TestResultChartData = {
+    percentage: number;
+    slices: TestResultSlice[];
+};
+export declare const getPieChartData: (stats: Statistic) => TestResultChartData;

package/dist/charts/getPieChart.js

@@ -0,0 +1,20 @@
+import { statusesList } from "@allurereport/core-api";
+import { d3Arc, d3Pie, getPercentage } from "../charts.js";
+export const getPieChartData = (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,
+    };
+};

package/dist/charts/getPieChartDashboard.d.ts

@@ -0,0 +1,3 @@
+import type { Statistic } from "@allurereport/core-api";
+import type { PieChartData, PieChartOptions } from "../charts.js";
+export declare const getPieChartDataDashboard: (stats: Statistic, chartOptions: PieChartOptions) => PieChartData;

package/dist/charts/getPieChartDashboard.js

@@ -0,0 +1,22 @@
+import { statusesList } from "@allurereport/core-api";
+import { d3Arc, d3Pie, getPercentage } from "../charts.js";
+export const getPieChartDataDashboard = (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/getSeverityTrendData.d.ts

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

package/dist/charts/getSeverityTrendData.js

@@ -0,0 +1,46 @@
+import { severityLabelName, severityLevels } from "@allurereport/core-api";
+import { createEmptySeries, createEmptyStats, getTrendDataGeneric, mergeTrendDataGeneric, normalizeStatistic, } from "../charts.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/getStatusTrendData.d.ts

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

package/dist/charts/getStatusTrendData.js

@@ -0,0 +1,37 @@
+import { statusesList } from "@allurereport/core-api";
+import { createEmptySeries, createEmptyStats, getTrendDataGeneric, mergeTrendDataGeneric, normalizeStatistic, } from "../charts.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/charts.d.ts

@@ -0,0 +1,106 @@
+import type { SeverityLevel, TestResult, TestStatus } from "@allurereport/core-api";
+import type { PieArcDatum } from "d3-shape";
+export type BasePieSlice = Pick<PieSlice, "status" | "count">;
+export declare const DEFAULT_CHART_HISTORY_LIMIT = 10;
+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 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 TrendDataType = TestStatus | SeverityLevel;
+export type TrendCalculationResult<T extends TrendDataType> = {
+    points: Record<TrendPointId, TrendPoint>;
+    series: Record<T, TrendPointId[]>;
+};
+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>;

package/dist/charts.js

@@ -0,0 +1,118 @@
+import { arc, pie } from "d3-shape";
+export const DEFAULT_CHART_HISTORY_LIMIT = 10;
+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 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 = {}));
+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/data.d.ts

@@ -5,7 +5,11 @@ export declare const createReportDataScript: (reportFiles?: {
 }[]) => string;
 export declare const ensureReportDataReady: () => Promise<unknown>;
 export declare const loadReportData: (name: string) => Promise<string>;
-export declare const reportDataUrl: (path: string, contentType?: string) => Promise<string>;
-export declare const fetchReportJsonData: <T>(path: string) => Promise<T>;
+export declare const reportDataUrl: (path: string, contentType?: string, params?: {
+    bustCache: boolean;
+}) => Promise<string>;
+export declare const fetchReportJsonData: <T>(path: string, params?: {
+    bustCache: boolean;
+}) => Promise<T>;
 export declare const fetchReportAttachment: (path: string, contentType?: string) => Promise<Response>;
 export declare const getReportOptions: <T>() => T;

package/dist/data.js

@@ -49,22 +49,26 @@ export const loadReportData = async (name) => {
         }
     });
 };
-export const reportDataUrl = async (path, contentType = "application/octet-stream") => {
+export const reportDataUrl = async (path, contentType = "application/octet-stream", params) => {
     if (globalThis.allureReportData) {
-        const dataKey = path.replace(/\?attachment$/, "");
+        const [dataKey] = path.split("?");
         const value = await loadReportData(dataKey);
         return `data:${contentType};base64,${value}`;
     }
     const baseEl = globalThis.document.head.querySelector("base")?.href ?? "https://localhost";
     const url = new URL(path, baseEl);
     const liveReloadHash = globalThis.localStorage.getItem(ALLURE_LIVE_RELOAD_HASH_STORAGE_KEY);
+    const cacheKey = globalThis.allureReportOptions?.cacheKey;
     if (liveReloadHash) {
         url.searchParams.set("live_reload_hash", liveReloadHash);
     }
-    return url.pathname + url.search + url.hash;
+    if (params?.bustCache && cacheKey) {
+        url.searchParams.set("v", cacheKey);
+    }
+    return url.toString();
 };
-export const fetchReportJsonData = async (path) => {
-    const url = await reportDataUrl(path);
+export const fetchReportJsonData = async (path, params) => {
+    const url = await reportDataUrl(path, undefined, params);
     const res = await globalThis.fetch(url);
     if (!res.ok) {
         throw new Error(`Failed to fetch ${url}, response status: ${res.status}`);

package/dist/index.d.ts

@@ -3,3 +3,8 @@ export * from "./static.js";
 export * from "./attachments.js";
 export * from "./i18n.js";
 export * from "./strings.js";
+export * from "./charts.js";
+export * from "./charts/getPieChart.js";
+export * from "./charts/getPieChartDashboard.js";
+export * from "./charts/getSeverityTrendData.js";
+export * from "./charts/getStatusTrendData.js";

package/dist/index.js

@@ -3,3 +3,8 @@ export * from "./static.js";
 export * from "./attachments.js";
 export * from "./i18n.js";
 export * from "./strings.js";
+export * from "./charts.js";
+export * from "./charts/getPieChart.js";
+export * from "./charts/getPieChartDashboard.js";
+export * from "./charts/getSeverityTrendData.js";
+export * from "./charts/getStatusTrendData.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/web-commons",
-  "version": "3.0.0-beta.13",
+  "version": "3.0.0-beta.15",
   "description": "Collection of utilities used across the web Allure reports",
   "keywords": [
     "allure",
@@ -23,16 +23,18 @@
     "clean": "rimraf ./dist"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.0.0-beta.13"
+    "@allurereport/core-api": "3.0.0-beta.15"
   },
   "devDependencies": {
     "@stylistic/eslint-plugin": "^2.6.1",
+    "@types/d3-shape": "^3.1.6",
     "@types/eslint": "^8.56.11",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
     "@vitest/runner": "^2.1.8",
     "allure-js-commons": "^3.0.9",
     "allure-vitest": "^3.0.9",
+    "d3-shape": "^3.2.0",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.29.1",