@allurereport/web-commons 3.0.0-beta.8 → 3.0.0

package/dist/charts/generateTestingPyramidChart.js

@@ -0,0 +1,52 @@
+import { ChartType } from "@allurereport/charts-api";
+const DEFAULT_LAYERS = ["unit", "integration", "e2e"];
+const getPercentage = (value, total) => {
+    if (total === 0 || value === 0) {
+        return 0;
+    }
+    return Math.floor((value / total) * 10000) / 100;
+};
+export const generateTestingPyramidChart = (chartOptions, storeData) => {
+    const { layers = DEFAULT_LAYERS, title } = chartOptions;
+    const { testResults } = storeData;
+    const layersMap = new Map();
+    layers.forEach((layer) => {
+        layersMap.set(layer, layer);
+        layersMap.set(layer.toLocaleLowerCase(), layer);
+    });
+    const statsByLayers = new Map();
+    layers.forEach((layer) => {
+        statsByLayers.set(layer, {
+            passed: 0,
+            total: 0,
+        });
+    });
+    for (const testResult of testResults) {
+        const trLayer = testResult.labels.find((label) => label.name === "layer")?.value;
+        if (!trLayer) {
+            continue;
+        }
+        const layer = layersMap.get(trLayer.toLocaleLowerCase());
+        if (!layer) {
+            continue;
+        }
+        const data = statsByLayers.get(layer);
+        data.total++;
+        if (testResult.status === "passed") {
+            data.passed++;
+        }
+    }
+    return {
+        type: ChartType.TestingPyramid,
+        title,
+        data: layers.map((layer) => {
+            const data = statsByLayers.get(layer);
+            return {
+                layer,
+                testCount: data.total,
+                successRate: getPercentage(data.passed, data.total),
+                percentage: getPercentage(data.total, testResults.length),
+            };
+        }),
+    };
+};

package/dist/charts/generateTrSeveritiesChart.d.ts

@@ -0,0 +1,5 @@
+import type { AllureChartsStoreData, TrSeveritiesChartData, TrSeveritiesChartOptions } from "@allurereport/charts-api";
+export declare const generateTrSeveritiesChart: (props: {
+    options: TrSeveritiesChartOptions;
+    storeData: AllureChartsStoreData;
+}) => TrSeveritiesChartData;

package/dist/charts/generateTrSeveritiesChart.js

@@ -0,0 +1,53 @@
+import { ChartType } from "@allurereport/charts-api";
+import { severityLabelName, severityLevels, statusesList } from "@allurereport/core-api";
+const DEFAULT_SEVERITY_LEVELS = [...severityLevels];
+const UNSET_SEVERITY_LEVEL = "unset";
+const SEVERITY_LABEL_NAME = severityLabelName;
+const getSeverity = (tr) => {
+    const severityLabelValue = tr.labels?.find((label) => label.name === SEVERITY_LABEL_NAME)?.value;
+    if (!severityLabelValue) {
+        return UNSET_SEVERITY_LEVEL;
+    }
+    return severityLabelValue;
+};
+export const generateTrSeveritiesChart = (props) => {
+    const { options, storeData } = props;
+    const { levels, statuses, includeUnset = true } = options;
+    let trSeverityLevels = levels;
+    let trStatuses = statuses;
+    if (!trSeverityLevels || trSeverityLevels.length === 0) {
+        trSeverityLevels = DEFAULT_SEVERITY_LEVELS;
+    }
+    if (includeUnset) {
+        trSeverityLevels.push(UNSET_SEVERITY_LEVEL);
+    }
+    if (!trStatuses || trStatuses.length === 0) {
+        trStatuses = statusesList;
+    }
+    const { testResults } = storeData;
+    const data = new Map();
+    for (const severity of trSeverityLevels) {
+        data.set(severity, Object.fromEntries(trStatuses.map((status) => [status, 0])));
+    }
+    for (const tr of testResults) {
+        if (!trStatuses.includes(tr.status)) {
+            continue;
+        }
+        const severity = getSeverity(tr);
+        if (!trSeverityLevels.includes(severity)) {
+            continue;
+        }
+        const severityStats = data.get(severity);
+        severityStats[tr.status]++;
+    }
+    return {
+        type: ChartType.TrSeverities,
+        title: options.title,
+        data: trSeverityLevels.map((severity) => ({
+            id: severity,
+            ...data.get(severity),
+        })),
+        levels: trSeverityLevels,
+        statuses: trStatuses,
+    };
+};

package/dist/charts/generators.d.ts

@@ -0,0 +1,10 @@
+import { type ChartOptions, type GeneratedChartsData } from "@allurereport/charts-api";
+import { type AllureStore } from "@allurereport/plugin-api";
+type ChartsWidgetData = {
+    general: GeneratedChartsData;
+    byEnv: {
+        [env: string]: GeneratedChartsData;
+    };
+};
+export declare const generateCharts: (chartsOptions: ChartOptions[], store: AllureStore, reportName: string, generateUuid: () => string) => Promise<ChartsWidgetData>;
+export {};

package/dist/charts/generators.js

@@ -0,0 +1,97 @@
+import { ChartType, } from "@allurereport/charts-api";
+import { DEFAULT_ENVIRONMENT } from "@allurereport/core-api";
+import { generateCurrentStatusChart } from "./generateCurrentStatusChart.js";
+import { generateDurationDynamicsChart } from "./generateDurationDynamicsChart.js";
+import { generateDurationsChart } from "./generateDurationsChart.js";
+import { generateFBSUAgePyramid } from "./generateFBSUAgePyramid.js";
+import { generateStabilityDistributionChart } from "./generateStabilityDistributionChart.js";
+import { generateStatusDynamicsChart } from "./generateStatusDynamicsChart.js";
+import { generateStatusTransitionsChart } from "./generateStatusTransitionsChart.js";
+import { generateTestBaseGrowthDynamicsChart } from "./generateTestBaseGrowthDynamicsChart.js";
+import { generateTestingPyramidChart } from "./generateTestingPyramidChart.js";
+import { generateTrSeveritiesChart } from "./generateTrSeveritiesChart.js";
+import { generateHeatMapChart } from "./heatMap.js";
+import { generateTreeMapChart } from "./treeMap.js";
+const generateChartData = async (props) => {
+    const { env, chartsOptions, store, reportName, generateUuid } = props;
+    const result = {};
+    const storeData = await Promise.all([
+        env ? await store.allHistoryDataPointsByEnvironment(env) : await store.allHistoryDataPoints(),
+        env ? await store.testResultsByEnvironment(env) : await store.allTestResults(),
+        env ? await store.testsStatistic((tr) => tr.environment === env) : await store.testsStatistic(),
+    ]).then(([historyDataPoints, testResults, statistic]) => ({
+        historyDataPoints,
+        testResults,
+        statistic,
+    }));
+    for (const chartOption of chartsOptions) {
+        const chartId = generateUuid();
+        switch (chartOption.type) {
+            case ChartType.CurrentStatus:
+                result[chartId] = generateCurrentStatusChart(chartOption, storeData);
+                break;
+            case ChartType.StatusDynamics:
+                result[chartId] = generateStatusDynamicsChart({ options: chartOption, storeData });
+                break;
+            case ChartType.StatusTransitions:
+                result[chartId] = generateStatusTransitionsChart({ options: chartOption, storeData });
+                break;
+            case ChartType.Durations:
+                result[chartId] = generateDurationsChart({ options: chartOption, storeData });
+                break;
+            case ChartType.DurationDynamics:
+                result[chartId] = generateDurationDynamicsChart({ options: chartOption, storeData });
+                break;
+            case ChartType.StabilityDistribution:
+                result[chartId] = generateStabilityDistributionChart({ options: chartOption, storeData });
+                break;
+            case ChartType.TestBaseGrowthDynamics:
+                result[chartId] = generateTestBaseGrowthDynamicsChart({ options: chartOption, storeData });
+                break;
+            case ChartType.FBSUAgePyramid:
+                result[chartId] = generateFBSUAgePyramid({ options: chartOption, storeData });
+                break;
+            case ChartType.TrSeverities:
+                result[chartId] = generateTrSeveritiesChart({ options: chartOption, storeData });
+                break;
+            case ChartType.CoverageDiff:
+                result[chartId] = generateTreeMapChart(chartOption, storeData);
+                break;
+            case ChartType.SuccessRateDistribution:
+                result[chartId] = generateTreeMapChart(chartOption, storeData);
+                break;
+            case ChartType.ProblemsDistribution:
+                result[chartId] = generateHeatMapChart(chartOption, storeData);
+                break;
+            case ChartType.TestingPyramid:
+                result[chartId] = generateTestingPyramidChart(chartOption, storeData);
+                break;
+            default:
+                break;
+        }
+    }
+    return result;
+};
+const hasOnlyDefaultEnvironment = (environments) => {
+    return environments.length === 1 && environments[0] === DEFAULT_ENVIRONMENT;
+};
+export const generateCharts = async (chartsOptions, store, reportName, generateUuid) => {
+    const environments = await store.allEnvironments();
+    const chartsData = {
+        general: await generateChartData({ chartsOptions, store, reportName, generateUuid }),
+        byEnv: {},
+    };
+    if (hasOnlyDefaultEnvironment(environments)) {
+        return chartsData;
+    }
+    for (const environment of environments) {
+        chartsData.byEnv[environment] = await generateChartData({
+            chartsOptions,
+            store,
+            reportName,
+            env: environment,
+            generateUuid,
+        });
+    }
+    return chartsData;
+};

package/dist/charts/heatMap.d.ts

@@ -0,0 +1,3 @@
+import type { AllureChartsStoreData, HeatMapChartData, HeatMapChartOptions, HeatMapDataAccessor } from "@allurereport/charts-api";
+export declare const generateHeatMapChartGeneric: <T extends Record<string, unknown>>(options: HeatMapChartOptions, storeData: AllureChartsStoreData, dataAccessor: HeatMapDataAccessor<T>) => HeatMapChartData | undefined;
+export declare const generateHeatMapChart: (options: HeatMapChartOptions, storeData: AllureChartsStoreData) => HeatMapChartData | undefined;

package/dist/charts/heatMap.js

@@ -0,0 +1,9 @@
+import { problemsDistributionHeatMapAccessor } from "./accessors/problemsDistributionHeatMap.js";
+export const generateHeatMapChartGeneric = (options, storeData, dataAccessor) => ({
+    type: options.type,
+    title: options.title,
+    data: dataAccessor.getHeatMap(storeData),
+});
+export const generateHeatMapChart = (options, storeData) => {
+    return generateHeatMapChartGeneric(options, storeData, problemsDistributionHeatMapAccessor);
+};

package/dist/charts/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./utils.js";
+export type * from "./types.js";
+export * from "./colors.js";
+export * from "./chart-utils.js";
+export * from "./line.js";
+export * from "./treeMap.js";
+export * from "./heatMap.js";
+export * from "./d3pie.js";
+export * from "./generators.js";

package/dist/charts/index.js

@@ -0,0 +1,8 @@
+export * from "./utils.js";
+export * from "./colors.js";
+export * from "./chart-utils.js";
+export * from "./line.js";
+export * from "./treeMap.js";
+export * from "./heatMap.js";
+export * from "./d3pie.js";
+export * from "./generators.js";

package/dist/charts/line.d.ts

@@ -0,0 +1,8 @@
+import type { AllureChartsStoreData, BaseTrendSliceMetadata, GenericTrendChartData, TrendCalculationResult, TrendChartData, TrendDataAccessor, TrendDataType } from "@allurereport/charts-api";
+type TrendChartOptions = Record<string, any>;
+export declare const calculatePercentValues: <T extends TrendDataType>(stats: Record<T, number>, executionId: string, itemType: readonly T[]) => TrendCalculationResult<T>;
+export declare const getTrendDataGeneric: <T extends TrendDataType, M extends BaseTrendSliceMetadata>(stats: Record<T, number>, reportName: string, executionOrder: number, itemType: readonly T[], chartOptions: TrendChartOptions) => GenericTrendChartData<T, M>;
+export declare const mergeTrendDataGeneric: <T extends TrendDataType, M extends BaseTrendSliceMetadata>(trendData: GenericTrendChartData<T, M>, trendDataPart: GenericTrendChartData<T, M>, itemType: readonly T[]) => GenericTrendChartData<T, M>;
+export declare const generateTrendChartGeneric: <T extends TrendDataType>(options: TrendChartOptions, storeData: AllureChartsStoreData, dataAccessor: TrendDataAccessor<T>, reportName: string) => GenericTrendChartData<T> | undefined;
+export declare const generateTrendChart: (options: TrendChartOptions, storeData: AllureChartsStoreData, reportName: string) => TrendChartData | undefined;
+export {};

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/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,87 @@
+import { ChartType } 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,
+    title: options.title,
+    treeMap: dataAccessor.getTreeMap(storeData),
+});
+export const generateTreeMapChart = (options, storeData) => {
+    const { type } = options;
+    if (type === ChartType.SuccessRateDistribution) {
+        return generateTreeMapChartGeneric(options, storeData, successRateDistributionTreeMapAccessor);
+    }
+    else if (type === ChartType.CoverageDiff) {
+        return generateTreeMapChartGeneric(options, storeData, coverageDiffTreeMapAccessor);
+    }
+};

package/dist/charts/types.d.ts

@@ -0,0 +1,76 @@
+import type { ChartId, ChartType, DurationDynamicsChartData, DurationsChartData, FBSUAgePyramidChartData, HeatMapSerie, StabilityDistributionChartData, StatusTransitionsChartData, TestBaseGrowthDynamicsChartData, TestingPyramidChartData, TrSeveritiesChartData, TreeMapNode } from "@allurereport/charts-api";
+import type { Statistic, TestStatus } from "@allurereport/core-api";
+export type TreeMapTooltipAccessor = <T>(node: T) => string[];
+export interface Point {
+    x: Date | string | number;
+    y: number;
+}
+export interface TrendChartItem {
+    id: string;
+    data: Point[];
+    color: string;
+}
+export interface CurrentStatusChartData {
+    type: ChartType.CurrentStatus;
+    title?: string;
+    data: Statistic;
+    statuses?: TestStatus[];
+    metric?: TestStatus;
+}
+export interface StatusDynamicsChartData {
+    type: ChartType.StatusDynamics;
+    title?: string;
+    data: {
+        statistic: Statistic;
+        id: string;
+        timestamp: number;
+        name: string;
+    }[];
+    limit?: number;
+    statuses?: TestStatus[];
+}
+export interface ResponseTreeMapChartData {
+    type: ChartType.CoverageDiff | ChartType.SuccessRateDistribution;
+    title?: string;
+    treeMap: TreeMapNode;
+}
+export interface ResponseHeatMapChartData {
+    type: ChartType.ProblemsDistribution;
+    title?: string;
+    data: HeatMapSerie[];
+}
+export type ChartsResponse = {
+    general: Record<ChartId, CurrentStatusChartData | ResponseTreeMapChartData | ResponseHeatMapChartData>;
+    byEnv: {
+        [env: string]: Record<ChartId, CurrentStatusChartData | ResponseTreeMapChartData | ResponseHeatMapChartData>;
+    };
+};
+export type UICurrentStatusChartData = CurrentStatusChartData;
+export type UIStatusDynamicsChartData = StatusDynamicsChartData;
+export type UIStatusTransitionsChartData = StatusTransitionsChartData;
+export type UIDurationsChartData = DurationsChartData;
+export interface UITreeMapChartData extends ResponseTreeMapChartData {
+    colors: (value: number, domain?: number[]) => string;
+    formatLegend?: (value: number) => string;
+    legendDomain?: number[];
+    tooltipRows?: TreeMapTooltipAccessor;
+}
+export interface UIHeatMapChartData extends ResponseHeatMapChartData {
+    colors: (value: number, domain?: number[]) => string;
+}
+export type ChartData = CurrentStatusChartData | StatusDynamicsChartData | StatusTransitionsChartData | DurationsChartData | StabilityDistributionChartData | ResponseTreeMapChartData | ResponseHeatMapChartData | TestBaseGrowthDynamicsChartData | FBSUAgePyramidChartData | TrSeveritiesChartData | DurationDynamicsChartData | TestingPyramidChartData;
+export type UIChartData = UICurrentStatusChartData | UIStatusDynamicsChartData | UITreeMapChartData | UIHeatMapChartData | UIStatusTransitionsChartData | UIDurationsChartData | TestBaseGrowthDynamicsChartData | FBSUAgePyramidChartData | StabilityDistributionChartData | TrSeveritiesChartData | DurationDynamicsChartData | TestingPyramidChartData;
+export type ChartsData = Record<ChartId, ChartData>;
+export type ChartsDataWithEnvs = {
+    general: Record<ChartId, ChartData>;
+    byEnv: {
+        [env: string]: Record<ChartId, ChartData>;
+    };
+};
+export type UIChartsData = Record<ChartId, UIChartData>;
+export type UIChartsDataWithEnvs = {
+    general: UIChartsData;
+    byEnv: {
+        [env: string]: UIChartsData;
+    };
+};

package/dist/charts/types.js

@@ -0,0 +1 @@
+export {};

package/dist/charts/utils.d.ts

@@ -0,0 +1,21 @@
+import type { ChartId } from "@allurereport/charts-api";
+import type { ChartsData, ChartsDataWithEnvs, ResponseHeatMapChartData, ResponseTreeMapChartData, TreeMapTooltipAccessor, UIChartData, UIChartsDataWithEnvs, UIHeatMapChartData, UITreeMapChartData } from "./types.js";
+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 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 createTreeMapChartData: (chartId: ChartId, chartData: ResponseTreeMapChartData, res: ChartsData) => UITreeMapChartData | 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;
+export declare const createHashStorage: () => {
+    get: (key: string) => string;
+    set: (key: string, value: string) => Map<string, string>;
+};
+export declare const createMapWithDefault: <K, V>(defaultValue: V) => {
+    readonly set: (key: K, value: V) => Map<K, V>;
+    readonly get: (key: K) => NonNullable<V>;
+    readonly values: V[];
+    readonly entries: [K, V][];
+};