@allurereport/web-commons 3.0.0-beta.20 → 3.0.0-beta.22

package/dist/charts/line.js

@@ -0,0 +1,140 @@
+import { ChartDataType, ChartMode, DEFAULT_CHART_HISTORY_LIMIT } from "@allurereport/charts-api";
+import { severityTrendDataAccessor } from "./accessors/severityTrendAccessor.js";
+import { statusTrendDataAccessor } from "./accessors/statusTrendAccessor.js";
+import { createEmptySeries, normalizeStatistic } from "./chart-utils.js";
+export 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,
+        };
+        series[item].push(pointId);
+    });
+    return { points, series };
+};
+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 };
+};
+export const getTrendDataGeneric = (stats, reportName, executionOrder, itemType, chartOptions) => {
+    const { type, dataType, title, mode = ChartMode.Raw, metadata = {} } = chartOptions;
+    const { executionIdAccessor, executionNameAccessor } = metadata;
+    const executionId = executionIdAccessor ? executionIdAccessor(executionOrder) : `execution-${executionOrder}`;
+    const { points, series } = mode === ChartMode.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,
+        mode,
+        title,
+        points,
+        slices,
+        series,
+        min,
+        max,
+    };
+};
+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 generateTrendChartGeneric = (options, storeData, dataAccessor, reportName) => {
+    const { limit } = options;
+    const historyLimit = limit && limit > 0 ? Math.max(0, limit - 1) : undefined;
+    const { historyDataPoints } = storeData;
+    const currentData = dataAccessor.getCurrentData(storeData);
+    const limitedHistoryPoints = historyLimit !== undefined ? historyDataPoints.slice(-historyLimit) : historyDataPoints;
+    const firstOriginalIndex = historyLimit !== undefined ? Math.max(0, historyDataPoints.length - historyLimit) : 0;
+    const convertedHistoryPoints = limitedHistoryPoints.map((point, index) => {
+        const originalIndex = firstOriginalIndex + index;
+        return {
+            name: point.name,
+            originalIndex,
+            statistic: dataAccessor.getHistoricalData(point),
+        };
+    });
+    const allValues = dataAccessor.getAllValues();
+    const currentTrendData = getTrendDataGeneric(normalizeStatistic(currentData, allValues), reportName, historyDataPoints.length + 1, allValues, options);
+    const historicalTrendData = convertedHistoryPoints.reduce((acc, historyPoint) => {
+        const trendDataPart = getTrendDataGeneric(normalizeStatistic(historyPoint.statistic, allValues), historyPoint.name, historyPoint.originalIndex + 1, allValues, options);
+        return mergeTrendDataGeneric(acc, trendDataPart, allValues);
+    }, {
+        type: options.type,
+        dataType: options.dataType,
+        mode: options.mode,
+        title: options.title,
+        points: {},
+        slices: {},
+        series: createEmptySeries(allValues),
+        min: Infinity,
+        max: -Infinity,
+    });
+    return mergeTrendDataGeneric(historicalTrendData, currentTrendData, allValues);
+};
+export const generateTrendChart = (options, storeData, reportName) => {
+    const newOptions = { limit: DEFAULT_CHART_HISTORY_LIMIT, ...options };
+    const { dataType } = newOptions;
+    if (dataType === ChartDataType.Status) {
+        return generateTrendChartGeneric(newOptions, storeData, statusTrendDataAccessor, reportName);
+    }
+    else if (dataType === ChartDataType.Severity) {
+        return generateTrendChartGeneric(newOptions, storeData, severityTrendDataAccessor, reportName);
+    }
+};

package/dist/charts/pie.d.ts

@@ -0,0 +1,6 @@
+import type { PieChartData, PieChartOptions } from "@allurereport/charts-api";
+import type { Statistic } from "@allurereport/core-api";
+export declare const getPieChartData: (stats: Statistic, chartOptions: PieChartOptions) => PieChartData;
+export declare const generatePieChart: (options: PieChartOptions, stores: {
+    statistic: Statistic;
+}) => PieChartData;

package/dist/charts/pie.js

@@ -0,0 +1,10 @@
+import { getPieChartValues } from "./d3pie.js";
+export const getPieChartData = (stats, chartOptions) => ({
+    type: chartOptions.type,
+    title: chartOptions?.title,
+    ...getPieChartValues(stats),
+});
+export const generatePieChart = (options, stores) => {
+    const { statistic } = stores;
+    return getPieChartData(statistic, options);
+};

package/dist/charts/treeMap.d.ts

@@ -0,0 +1,6 @@
+import type { AllureChartsStoreData, TreeMapChartData, TreeMapChartOptions, TreeMapDataAccessor, TreeMapNode } from "@allurereport/charts-api";
+import type { TreeData, TreeGroup, TreeLeaf, WithChildren } from "@allurereport/core-api";
+export declare const convertTreeDataToTreeMapNode: <T extends TreeMapNode, L, G>(treeData: TreeData<L, G>, transform: (treeDataNode: TreeLeaf<L> | TreeGroup<G>, isGroup: boolean, parentNode?: TreeGroup<G>) => T, transformRoot?: (root: WithChildren) => T) => T;
+export declare const transformTreeMapNode: <T extends TreeMapNode>(tree: T, transform: (node: T) => T) => T;
+export declare const generateTreeMapChartGeneric: <T extends TreeMapNode>(options: TreeMapChartOptions, storeData: AllureChartsStoreData, dataAccessor: TreeMapDataAccessor<T>) => TreeMapChartData | undefined;
+export declare const generateTreeMapChart: (options: TreeMapChartOptions, storeData: AllureChartsStoreData) => TreeMapChartData | undefined;

package/dist/charts/treeMap.js

@@ -0,0 +1,88 @@
+import { TreeMapChartType } from "@allurereport/charts-api";
+import { coverageDiffTreeMapAccessor } from "./accessors/coverageDiffTreeMapAccessor.js";
+import { successRateDistributionTreeMapAccessor } from "./accessors/successRateDistributionTreeMapAccessor.js";
+export const convertTreeDataToTreeMapNode = (treeData, transform, transformRoot = () => ({
+    id: "root",
+    value: undefined,
+})) => {
+    const { root, leavesById, groupsById } = treeData;
+    const convertNode = (nodeId, parentGroup, isGroup) => {
+        const node = isGroup ? groupsById[nodeId] : leavesById[nodeId];
+        if (!node) {
+            return null;
+        }
+        const treeMapNode = transform(node, isGroup, parentGroup);
+        if (isGroup) {
+            const group = node;
+            const children = [];
+            if (group.groups) {
+                group.groups.forEach((groupId) => {
+                    const childNode = convertNode(groupId, group, true);
+                    if (childNode) {
+                        children.push(childNode);
+                    }
+                });
+            }
+            if (group.leaves) {
+                group.leaves.forEach((leafId) => {
+                    const childNode = convertNode(leafId, group, false);
+                    if (childNode) {
+                        children.push(childNode);
+                    }
+                });
+            }
+            if (children.length === 0) {
+                return null;
+            }
+            treeMapNode.children = children;
+        }
+        return treeMapNode;
+    };
+    const rootChildren = [];
+    if (root.groups) {
+        root.groups.forEach((groupId) => {
+            const childNode = convertNode(groupId, root, true);
+            if (childNode) {
+                rootChildren.push(childNode);
+            }
+        });
+    }
+    if (root.leaves) {
+        root.leaves.forEach((leafId) => {
+            const childNode = convertNode(leafId, root, false);
+            if (childNode) {
+                rootChildren.push(childNode);
+            }
+        });
+    }
+    return {
+        children: rootChildren.length > 0 ? rootChildren : undefined,
+        ...transformRoot(root),
+    };
+};
+export const transformTreeMapNode = (tree, transform) => {
+    const transformedNode = transform(tree);
+    if (transformedNode.children) {
+        const transformedChildren = transformedNode.children.map((child) => transformTreeMapNode(child, transform));
+        return {
+            ...transformedNode,
+            children: transformedChildren,
+        };
+    }
+    return transformedNode;
+};
+export const generateTreeMapChartGeneric = (options, storeData, dataAccessor) => ({
+    type: options.type,
+    dataType: options.dataType,
+    title: options.title,
+    treeMap: dataAccessor.getTreeMap(storeData),
+});
+export const generateTreeMapChart = (options, storeData) => {
+    const { dataType } = options;
+    if (dataType === TreeMapChartType.SuccessRateDistribution) {
+        return generateTreeMapChartGeneric(options, storeData, successRateDistributionTreeMapAccessor);
+    }
+    else if (dataType === TreeMapChartType.CoverageDiff) {
+        return generateTreeMapChartGeneric(options, storeData, coverageDiffTreeMapAccessor);
+    }
+};

package/dist/charts/types.d.ts

@@ -1,4 +1,4 @@
-import type { BarChartType, BarGroup, BarGroupMode, BaseTrendSliceMetadata, ChartDataType, ChartId, ChartMode, ChartType, HeatMapSerie, PieSlice, TreeMapChartType, TreeMapNode, TrendPointId, TrendSlice, TrendSliceId } from "@allurereport/core-api";
+import type { BarChartType, BarGroup, BarGroupMode, BaseTrendSliceMetadata, ChartDataType, ChartId, ChartMode, ChartType, FunnelChartType, HeatMapSerie, PieSlice, TreeMapChartType, TreeMapNode, TrendPointId, TrendSlice, TrendSliceId } from "@allurereport/charts-api";
 export type TreeMapTooltipAccessor = <T>(node: T) => string[];
 export interface Point {
     x: Date | string | number;
@@ -51,7 +51,12 @@ export interface ResponseHeatMapChartData {
     title?: string;
     data: HeatMapSerie[];
 }
-export type ChartsResponse<SeriesType extends string = string, Metadata extends BaseTrendSliceMetadata = BaseTrendSliceMetadata> = Record<ChartId, ResponseTrendChartData<SeriesType, Metadata> | ResponsePieChartData | ResponseBarChartData | ResponseComingSoonChartData | ResponseTreeMapChartData | ResponseHeatMapChartData>;
+export type ChartsResponse<SeriesType extends string = string, Metadata extends BaseTrendSliceMetadata = BaseTrendSliceMetadata> = {
+    general: Record<ChartId, ResponseTrendChartData<SeriesType, Metadata> | ResponsePieChartData | ResponseBarChartData | ResponseComingSoonChartData | ResponseTreeMapChartData | ResponseHeatMapChartData>;
+    byEnv: {
+        [env: string]: Record<ChartId, ResponseTrendChartData<SeriesType, Metadata> | ResponsePieChartData | ResponseBarChartData | ResponseComingSoonChartData | ResponseTreeMapChartData | ResponseHeatMapChartData>;
+    };
+};
 export interface UITrendChartData<Metadata extends BaseTrendSliceMetadata = BaseTrendSliceMetadata> {
     type: ChartType.Trend;
     dataType: ChartDataType;
@@ -65,6 +70,19 @@ export interface UITrendChartData<Metadata extends BaseTrendSliceMetadata = Base
 export type UIPieChartData = ResponsePieChartData;
 export interface UIBarChartData extends ResponseBarChartData {
     colors: Record<string, string>;
+    xAxisConfig?: {
+        legend?: string;
+        enabled?: boolean;
+        format?: string;
+    };
+    yAxisConfig?: {
+        legend?: string;
+        enabled?: boolean;
+        format?: string;
+        domain?: number[];
+    };
+    layout?: "horizontal" | "vertical";
+    threshold?: number;
 }
 export type UIComingSoonChartData = ResponseComingSoonChartData;
 export interface UITreeMapChartData extends ResponseTreeMapChartData {
@@ -76,7 +94,32 @@ export interface UITreeMapChartData extends ResponseTreeMapChartData {
 export interface UIHeatMapChartData extends ResponseHeatMapChartData {
     colors: (value: number, domain?: number[]) => string;
 }
-export type ChartData<SeriesType extends string = string, Metadata extends BaseTrendSliceMetadata = BaseTrendSliceMetadata> = ResponseTrendChartData<SeriesType, Metadata> | ResponsePieChartData | ResponseBarChartData | ResponseComingSoonChartData | ResponseTreeMapChartData | ResponseHeatMapChartData;
-export type UIChartData<Metadata extends BaseTrendSliceMetadata = BaseTrendSliceMetadata> = UITrendChartData<Metadata> | UIPieChartData | UIBarChartData | UIComingSoonChartData | UITreeMapChartData | UIHeatMapChartData;
+export interface UITestingPyramidChartData extends ResponseTestingPyramidChartData {
+}
+export interface ResponseTestingPyramidChartData {
+    type: ChartType.Funnel;
+    dataType: FunnelChartType;
+    title?: string;
+    data: {
+        layer: string;
+        testCount: number;
+        successRate: number;
+        percentage: number;
+    }[];
+}
+export type ChartData<SeriesType extends string = string, Metadata extends BaseTrendSliceMetadata = BaseTrendSliceMetadata> = ResponseTrendChartData<SeriesType, Metadata> | ResponsePieChartData | ResponseBarChartData | ResponseComingSoonChartData | ResponseTreeMapChartData | ResponseHeatMapChartData | ResponseTestingPyramidChartData;
+export type UIChartData<Metadata extends BaseTrendSliceMetadata = BaseTrendSliceMetadata> = UITrendChartData<Metadata> | UIPieChartData | UIBarChartData | UIComingSoonChartData | UITreeMapChartData | UIHeatMapChartData | UITestingPyramidChartData;
 export type ChartsData<SeriesType extends string = string, Metadata extends BaseTrendSliceMetadata = BaseTrendSliceMetadata> = Record<ChartId, ChartData<SeriesType, Metadata>>;
+export type ChartsDataWithEnvs<SeriesType extends string = string, Metadata extends BaseTrendSliceMetadata = BaseTrendSliceMetadata> = {
+    general: Record<ChartId, ChartData<SeriesType, Metadata>>;
+    byEnv: {
+        [env: string]: Record<ChartId, ChartData<SeriesType, Metadata>>;
+    };
+};
 export type UIChartsData<Metadata extends BaseTrendSliceMetadata = BaseTrendSliceMetadata> = Record<ChartId, UIChartData<Metadata>>;
+export type UIChartsDataWithEnvs<Metadata extends BaseTrendSliceMetadata = BaseTrendSliceMetadata> = {
+    general: UIChartsData<Metadata>;
+    byEnv: {
+        [env: string]: UIChartsData<Metadata>;
+    };
+};

package/dist/charts/utils.d.ts

@@ -1,19 +1,25 @@
-import type { ChartId, SeverityLevel, TestStatus } from "@allurereport/core-api";
-import type { ChartsData, ChartsResponse, ResponseBarChartData, ResponseHeatMapChartData, ResponseTreeMapChartData, ResponseTrendChartData, TreeMapTooltipAccessor, UIBarChartData, UIChartData, UIHeatMapChartData, UITreeMapChartData, UITrendChartData } from "./types.js";
+import type { ChartId } from "@allurereport/charts-api";
+import type { SeverityLevel, TestStatus } from "@allurereport/core-api";
+import type { ChartsData, ChartsDataWithEnvs, ResponseBarChartData, ResponseHeatMapChartData, ResponseTestingPyramidChartData, ResponseTreeMapChartData, ResponseTrendChartData, TreeMapTooltipAccessor, UIBarChartData, UIChartData, UIChartsDataWithEnvs, UIHeatMapChartData, UITestingPyramidChartData, UITreeMapChartData, UITrendChartData } from "./types.js";
 export declare const createTrendChartDataGeneric: <T extends TestStatus | SeverityLevel>(getChart: () => ResponseTrendChartData | undefined, getGroups: () => readonly T[], getColor: (group: T) => string) => UITrendChartData | undefined;
 export declare const createBarChartDataGeneric: <T extends string>(getChart: () => ResponseBarChartData | undefined, getColors: () => Record<T, string>) => UIBarChartData | undefined;
 export declare const createTreeMapChartDataGeneric: (getChart: () => ResponseTreeMapChartData | undefined, colors: (value: number, domain?: number[]) => string, formatLegend?: (value: number) => string, legendDomain?: number[], tooltipRows?: TreeMapTooltipAccessor) => UITreeMapChartData | undefined;
 export declare const createHeatMapChartDataGeneric: (getChart: () => ResponseHeatMapChartData | undefined, colors: (value: number, domain?: number[]) => string) => UIHeatMapChartData | undefined;
-export declare const createStatusTrendChartData: (chartId: ChartId, res: ChartsResponse) => UITrendChartData | undefined;
-export declare const createSeverityTrendChartData: (chartId: ChartId, res: ChartsResponse) => UITrendChartData | undefined;
-export declare const createStatusBySeverityBarChartData: (chartId: ChartId, res: ChartsResponse) => UIBarChartData | undefined;
-export declare const createStatusTrendBarChartData: (chartId: ChartId, res: ChartsResponse) => UIBarChartData | undefined;
-export declare const createStatusChangeTrendBarChartData: (chartId: ChartId, res: ChartsResponse) => UIBarChartData | undefined;
-export declare const createSuccessRateDistributionTreeMapChartData: (chartId: ChartId, res: ChartsResponse) => UITreeMapChartData | undefined;
-export declare const createCoverageDiffTreeMapChartData: (chartId: ChartId, res: ChartsResponse) => UITreeMapChartData | undefined;
-export declare const createProblemsDistributionHeatMapChartData: (chartId: ChartId, res: ChartsResponse) => UIHeatMapChartData | undefined;
+export declare const createStatusTrendChartData: (chartId: ChartId, res: ChartsData) => UITrendChartData | undefined;
+export declare const createSeverityTrendChartData: (chartId: ChartId, res: ChartsData) => UITrendChartData | undefined;
+export declare const createStatusBySeverityBarChartData: (chartId: ChartId, res: ChartsData) => UIBarChartData | undefined;
+export declare const createStatusTrendBarChartData: (chartId: ChartId, res: ChartsData) => UIBarChartData | undefined;
+export declare const createStatusChangeTrendBarChartData: (chartId: ChartId, res: ChartsData) => UIBarChartData | undefined;
+export declare const createDurationsByLayerBarChartData: (chartId: ChartId, res: ChartsData) => UIBarChartData | undefined;
+export declare const createFbsuAgePyramidBarChartData: (chartId: ChartId, res: ChartsData) => UIBarChartData | undefined;
+export declare const createStabilityRateDistributionBarChartData: (chartId: ChartId, res: ChartsData) => UIBarChartData | undefined;
+export declare const createSuccessRateDistributionTreeMapChartData: (chartId: ChartId, res: ChartsData) => UITreeMapChartData | undefined;
+export declare const createCoverageDiffTreeMapChartData: (chartId: ChartId, res: ChartsData) => UITreeMapChartData | undefined;
+export declare const createProblemsDistributionHeatMapChartData: (chartId: ChartId, res: ChartsData) => UIHeatMapChartData | undefined;
 export declare const createaTrendChartData: (chartId: string, chartData: ResponseTrendChartData, res: ChartsData) => UITrendChartData | undefined;
 export declare const createBarChartData: (chartId: string, chartData: ResponseBarChartData, res: ChartsData) => UIBarChartData | undefined;
-export declare const createTreeMapChartData: (chartId: ChartId, chartData: ResponseTreeMapChartData, res: ChartsResponse) => UITreeMapChartData | undefined;
-export declare const createHeatMapChartData: (chartId: ChartId, res: ChartsResponse) => UIHeatMapChartData | undefined;
+export declare const createTreeMapChartData: (chartId: ChartId, chartData: ResponseTreeMapChartData, res: ChartsData) => UITreeMapChartData | undefined;
+export declare const createFunnelChartData: (chartId: string, chartData: ResponseTestingPyramidChartData) => UITestingPyramidChartData | undefined;
+export declare const createHeatMapChartData: (chartId: ChartId, res: ChartsData) => UIHeatMapChartData | undefined;
 export declare const createCharts: (res: ChartsData) => Record<ChartId, UIChartData>;
+export declare const createChartsWithEnvs: (res: ChartsDataWithEnvs) => UIChartsDataWithEnvs;

package/dist/charts/utils.js

@@ -1,7 +1,8 @@
-import { BarChartType, ChartDataType, ChartType, TreeMapChartType, severityLevels, statusesList, } from "@allurereport/core-api";
+import { BarChartType, ChartDataType, ChartType, FunnelChartType, TreeMapChartType } from "@allurereport/charts-api";
+import { severityLevels, statusesList } from "@allurereport/core-api";
 import { interpolateRgb } from "d3-interpolate";
 import { scaleLinear } from "d3-scale";
-import { resolveCSSVarColor, severityColors, statusChangeColors, statusColors } from "./colors.js";
+import { generateLayerColors, resolveCSSVarColor, severityColors, statusChangeColors, statusColors } from "./colors.js";
 export const createTrendChartDataGeneric = (getChart, getGroups, getColor) => {
     const chart = getChart();
     if (!chart) {
@@ -73,6 +74,37 @@ export const createSeverityTrendChartData = (chartId, res) => createTrendChartDa
 export const createStatusBySeverityBarChartData = (chartId, res) => createBarChartDataGeneric(() => res[chartId], () => statusColors);
 export const createStatusTrendBarChartData = (chartId, res) => createBarChartDataGeneric(() => res[chartId], () => statusColors);
 export const createStatusChangeTrendBarChartData = (chartId, res) => createBarChartDataGeneric(() => res[chartId], () => statusChangeColors);
+export const createDurationsByLayerBarChartData = (chartId, res) => {
+    const chart = res[chartId];
+    if (!chart) {
+        return undefined;
+    }
+    const layerNames = chart.keys;
+    return {
+        ...chart,
+        colors: generateLayerColors(layerNames),
+    };
+};
+export const createFbsuAgePyramidBarChartData = (chartId, res) => {
+    const chart = res[chartId];
+    if (!chart) {
+        return undefined;
+    }
+    return {
+        ...chart,
+        colors: statusColors,
+    };
+};
+export const createStabilityRateDistributionBarChartData = (chartId, res) => {
+    const chart = res[chartId];
+    if (!chart) {
+        return undefined;
+    }
+    return {
+        ...chart,
+        colors: {},
+    };
+};
 export const createSuccessRateDistributionTreeMapChartData = (chartId, res) => {
     const chartColorDomain = [0, 1];
     return createTreeMapChartDataGeneric(() => res[chartId], (value, domain = chartColorDomain) => {
@@ -132,14 +164,19 @@ export const createaTrendChartData = (chartId, chartData, res) => {
     }
 };
 export const createBarChartData = (chartId, chartData, res) => {
-    if (chartData.dataType === BarChartType.StatusBySeverity) {
-        return createStatusBySeverityBarChartData(chartId, res);
-    }
-    else if (chartData.dataType === BarChartType.StatusTrend) {
-        return createStatusTrendBarChartData(chartId, res);
-    }
-    else if (chartData.dataType === BarChartType.StatusChangeTrend) {
-        return createStatusChangeTrendBarChartData(chartId, res);
+    switch (chartData.dataType) {
+        case BarChartType.StatusBySeverity:
+            return createStatusBySeverityBarChartData(chartId, res);
+        case BarChartType.StatusTrend:
+            return createStatusTrendBarChartData(chartId, res);
+        case BarChartType.StatusChangeTrend:
+            return createStatusChangeTrendBarChartData(chartId, res);
+        case BarChartType.DurationsByLayer:
+            return createDurationsByLayerBarChartData(chartId, res);
+        case BarChartType.FbsuAgePyramid:
+            return createFbsuAgePyramidBarChartData(chartId, res);
+        case BarChartType.StabilityRateDistribution:
+            return createStabilityRateDistributionBarChartData(chartId, res);
     }
 };
 export const createTreeMapChartData = (chartId, chartData, res) => {
@@ -150,6 +187,12 @@ export const createTreeMapChartData = (chartId, chartData, res) => {
         return createCoverageDiffTreeMapChartData(chartId, res);
     }
 };
+export const createFunnelChartData = (chartId, chartData) => {
+    switch (chartData.dataType) {
+        case FunnelChartType.TestingPyramid:
+            return chartData;
+    }
+};
 export const createHeatMapChartData = (chartId, res) => {
     return createProblemsDistributionHeatMapChartData(chartId, res);
 };
@@ -179,9 +222,28 @@ export const createCharts = (res) => {
                 acc[chartId] = chartData;
             }
         }
+        else if (chart.type === ChartType.Funnel) {
+            const chartData = createFunnelChartData(chartId, chart);
+            if (chartData) {
+                acc[chartId] = chartData;
+            }
+        }
         else if ([ChartType.Pie, ChartType.ComingSoon].includes(chart.type)) {
-            acc[chartId] = chart;
+            return acc;
         }
         return acc;
     }, {});
 };
+export const createChartsWithEnvs = (res) => {
+    if (!("general" in res) && !("byEnv" in res)) {
+        return { general: createCharts(res), byEnv: {} };
+    }
+    const result = {
+        general: createCharts(res.general),
+        byEnv: {},
+    };
+    for (const [env, chartData] of Object.entries(res.byEnv)) {
+        result.byEnv[env] = createCharts(chartData);
+    }
+    return result;
+};

package/dist/sanitize.d.ts

@@ -1,15 +1 @@
-export declare const sanitize: {
-    (dirty: string | Node, cfg: import("dompurify").Config & {
-        RETURN_TRUSTED_TYPE: true;
-    }): import("trusted-types/lib/index.js").TrustedHTML;
-    (dirty: Node, cfg: import("dompurify").Config & {
-        IN_PLACE: true;
-    }): Node;
-    (dirty: string | Node, cfg: import("dompurify").Config & {
-        RETURN_DOM: true;
-    }): Node;
-    (dirty: string | Node, cfg: import("dompurify").Config & {
-        RETURN_DOM_FRAGMENT: true;
-    }): DocumentFragment;
-    (dirty: string | Node, cfg?: import("dompurify").Config): string;
-};
+export declare const sanitize: (html: string, config?: Record<string, any>) => string;

package/dist/sanitize.js

@@ -1,2 +1,2 @@
 import DOMPurify from "dompurify";
-export const sanitize = DOMPurify.sanitize.bind(DOMPurify);
+export const sanitize = (html, config) => DOMPurify.sanitize(html, config);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/web-commons",
-  "version": "3.0.0-beta.20",
+  "version": "3.0.0-beta.22",
   "description": "Collection of utilities used across the web Allure reports",
   "keywords": [
     "allure",
@@ -23,16 +23,20 @@
     "clean": "rimraf ./dist"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.0.0-beta.20",
+    "@allurereport/charts-api": "3.0.0-beta.22",
+    "@allurereport/core-api": "3.0.0-beta.22",
+    "@allurereport/plugin-api": "3.0.0-beta.22",
     "ansi-to-html": "^0.7.2",
     "d3-interpolate": "^3.0.1",
     "d3-scale": "^4.0.2",
+    "d3-shape": "^3.2.0",
     "dompurify": "^3.2.6"
   },
   "devDependencies": {
     "@stylistic/eslint-plugin": "^2.6.1",
     "@types/d3-interpolate": "^3.0.4",
     "@types/d3-scale": "^4.0.9",
+    "@types/d3-shape": "^3.1.6",
     "@types/eslint": "^8.56.11",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",