@allurereport/plugin-api 3.0.0-beta.20 → 3.0.0-beta.21

package/dist/charts/accessors/successRateDistributionTreeMapAccessor.js

@@ -1,111 +0,0 @@
-import { isChildrenLeavesOnly } from "../../charts.js";
-import { md5 } from "../../utils/misc.js";
-import { createTreeByLabels } from "../../utils/tree.js";
-import { convertTreeDataToTreeMapNode, transformTreeMapNode } from "../treeMap.js";
-import { behaviorLabels, filterTestsWithBehaviorLabels } from "./utils/behavior.js";
-const leafFactoryFn = ({ id, name, status }) => ({
-    nodeId: id,
-    name,
-    status,
-    value: 1,
-});
-const groupFactoryFn = (parentId, groupClassifier) => ({
-    nodeId: md5((parentId ? `${parentId}.` : "") + groupClassifier),
-    name: groupClassifier,
-    value: 0,
-    passedTests: 0,
-    failedTests: 0,
-    otherTests: 0,
-});
-const addLeafToGroupFn = (group, leaf) => {
-    group.value += leaf.value;
-    group.passedTests += leaf.status === "passed" ? 1 : 0;
-    group.failedTests += leaf.status === "failed" ? 1 : 0;
-    group.otherTests += leaf?.status && !["passed", "failed"].includes(leaf.status) ? 1 : 0;
-};
-const calculateColorValue = ({ totalTests, passedTests }) => {
-    return totalTests > 0 ? passedTests / totalTests : 0;
-};
-const calculateSubtreeMetrics = (node) => {
-    if (!node.children || node.children.length === 0) {
-        return {
-            totalTests: 1,
-            passedTests: node?.status === "passed" ? 1 : 0,
-            failedTests: node?.status === "failed" ? 1 : 0,
-            otherTests: node?.status && !["passed", "failed"].includes(node.status) ? 1 : 0,
-        };
-    }
-    let totalTests = 0;
-    let passedTests = 0;
-    let failedTests = 0;
-    let otherTests = 0;
-    for (const child of node.children) {
-        const childMetrics = calculateSubtreeMetrics(child);
-        totalTests += childMetrics.totalTests;
-        passedTests += childMetrics.passedTests;
-        failedTests += childMetrics.failedTests;
-        otherTests += childMetrics.otherTests;
-    }
-    return { totalTests, passedTests, failedTests, otherTests };
-};
-export const createSuccessRateDistributionTreeMap = (testResults) => {
-    const treeByLabels = createTreeByLabels(testResults, behaviorLabels, leafFactoryFn, groupFactoryFn, addLeafToGroupFn);
-    const convertedTree = convertTreeDataToTreeMapNode(treeByLabels, (node, isGroup) => {
-        const baseNode = {
-            id: node.name,
-            value: isGroup ? undefined : node.value,
-        };
-        if (isGroup) {
-            const group = node;
-            return {
-                ...baseNode,
-                passedTests: group.passedTests,
-                failedTests: group.failedTests,
-                otherTests: group.otherTests,
-            };
-        }
-        else {
-            const leaf = node;
-            return {
-                ...baseNode,
-                status: leaf.status,
-                passedTests: leaf?.status === "passed" ? 1 : 0,
-                failedTests: leaf?.status === "failed" ? 1 : 0,
-                otherTests: leaf?.status && !["passed", "failed"].includes(leaf.status) ? 1 : 0,
-            };
-        }
-    }, () => ({
-        id: "root",
-        passedTests: 0,
-        failedTests: 0,
-        otherTests: 0,
-    }));
-    return transformTreeMapNode(convertedTree, (node) => {
-        const subtreeMetrics = calculateSubtreeMetrics(node);
-        const colorValue = calculateColorValue(subtreeMetrics);
-        const { totalTests, ...restSubtreeMetrics } = subtreeMetrics;
-        if (isChildrenLeavesOnly(node)) {
-            const value = node.children?.reduce((acc, child) => {
-                return acc + (child.value ?? 0);
-            }, 0);
-            return {
-                ...node,
-                value,
-                children: undefined,
-                colorValue,
-                ...restSubtreeMetrics,
-            };
-        }
-        return {
-            ...node,
-            colorValue,
-            ...restSubtreeMetrics,
-        };
-    });
-};
-export const successRateDistributionTreeMapAccessor = {
-    getTreeMap: ({ testResults }) => {
-        const testsWithBehaviorLabels = filterTestsWithBehaviorLabels(testResults);
-        return createSuccessRateDistributionTreeMap(testsWithBehaviorLabels);
-    },
-};

package/dist/charts/accessors/utils/behavior.d.ts

@@ -1,5 +0,0 @@
-import type { HistoryTestResult, TestResult } from "@allurereport/core-api";
-export type BehaviorLabel = "epic" | "feature" | "story";
-export declare const behaviorLabels: BehaviorLabel[];
-export declare const hasBehaviorLabels: <T extends TestResult | HistoryTestResult>(test: T) => boolean;
-export declare const filterTestsWithBehaviorLabels: <T extends TestResult | HistoryTestResult>(tests: T[]) => T[];

package/dist/charts/accessors/utils/behavior.js

@@ -1,4 +0,0 @@
-import { hasLabels } from "../../../charts.js";
-export const behaviorLabels = ["epic", "feature", "story"];
-export const hasBehaviorLabels = (test) => hasLabels(test, behaviorLabels);
-export const filterTestsWithBehaviorLabels = (tests) => tests.filter(hasBehaviorLabels);

package/dist/charts/bar.d.ts

@@ -1,3 +0,0 @@
-import type { AllureChartsStoreData, BarChartData, BarChartOptions, BarDataAccessor } from "../charts.js";
-export declare const generateBarChartGeneric: <P extends string, T extends string>(options: BarChartOptions, storeData: AllureChartsStoreData, dataAccessor: BarDataAccessor<P, T>) => BarChartData | undefined;
-export declare const generateBarChart: (options: BarChartOptions, storeData: AllureChartsStoreData) => BarChartData | undefined;

package/dist/charts/bar.js

@@ -1,50 +0,0 @@
-import { BarChartType, ChartMode } from "@allurereport/core-api";
-import { DEFAULT_CHART_HISTORY_LIMIT, limitHistoryDataPoints } from "../charts.js";
-import { statusBySeverityBarDataAccessor } from "./accessors/statusBySeverityBarAccessor.js";
-import { statusChangeTrendBarAccessor } from "./accessors/statusChangeTrendBarAccessor.js";
-import { statusTrendBarAccessor } from "./accessors/statusTrendBarAccessor.js";
-export const generateBarChartGeneric = (options, storeData, dataAccessor) => {
-    const { type, dataType, title, limit = DEFAULT_CHART_HISTORY_LIMIT, mode = ChartMode.Raw } = options;
-    const { historyDataPoints } = storeData;
-    const limitedHistoryPoints = limitHistoryDataPoints(historyDataPoints, limit);
-    const isFullHistory = limitedHistoryPoints.length === historyDataPoints.length;
-    const items = dataAccessor.getItems(storeData, limitedHistoryPoints, isFullHistory);
-    let processedData = items;
-    if (mode === ChartMode.Percent) {
-        processedData = items.map((group) => {
-            const { groupId, ...values } = group;
-            const total = Object.values(values).reduce((sum, value) => sum + value, 0);
-            const nextValues = Object.keys(values).reduce((acc, valueKey) => {
-                acc[valueKey] = values[valueKey] / total;
-                return acc;
-            }, {});
-            return {
-                groupId,
-                ...nextValues,
-            };
-        });
-    }
-    return {
-        type,
-        dataType,
-        mode,
-        title,
-        data: processedData,
-        keys: dataAccessor.getGroupKeys(),
-        groupMode: dataAccessor.getGroupMode(),
-        indexBy: "groupId",
-    };
-};
-export const generateBarChart = (options, storeData) => {
-    const newOptions = { limit: DEFAULT_CHART_HISTORY_LIMIT, ...options };
-    const { dataType } = newOptions;
-    if (dataType === BarChartType.StatusBySeverity) {
-        return generateBarChartGeneric(newOptions, storeData, statusBySeverityBarDataAccessor);
-    }
-    else if (dataType === BarChartType.StatusTrend) {
-        return generateBarChartGeneric(newOptions, storeData, statusTrendBarAccessor);
-    }
-    else if (dataType === BarChartType.StatusChangeTrend) {
-        return generateBarChartGeneric(newOptions, storeData, statusChangeTrendBarAccessor);
-    }
-};

package/dist/charts/comingSoon.d.ts

@@ -1,2 +0,0 @@
-import type { ComingSoonChartData, ComingSoonChartOptions } from "../charts.js";
-export declare const generateComingSoonChart: (options: ComingSoonChartOptions) => ComingSoonChartData;

package/dist/charts/comingSoon.js

@@ -1,7 +0,0 @@
-import { ChartType } from "@allurereport/core-api";
-export const generateComingSoonChart = (options) => {
-    return {
-        type: ChartType.ComingSoon,
-        title: options.title,
-    };
-};

package/dist/charts/heatmap.d.ts

@@ -1,3 +0,0 @@
-import type { AllureChartsStoreData, HeatMapChartData, HeatMapChartOptions, HeatMapDataAccessor } from "../charts.js";
-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

@@ -1,9 +0,0 @@
-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/line.d.ts

@@ -1,8 +0,0 @@
-import type { BaseTrendSliceMetadata } from "@allurereport/core-api";
-import type { AllureChartsStoreData, GenericTrendChartData, TrendCalculationResult, TrendChartData, TrendChartOptions, TrendDataAccessor, TrendDataType } from "../charts.js";
-import type { PluginContext } from "../plugin.js";
-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, context: PluginContext, dataAccessor: TrendDataAccessor<T>) => GenericTrendChartData<T> | undefined;
-export declare const generateTrendChart: (options: TrendChartOptions, storeData: AllureChartsStoreData, context: PluginContext) => TrendChartData | undefined;

package/dist/charts/line.js

@@ -1,140 +0,0 @@
-import { ChartDataType, ChartMode } from "@allurereport/core-api";
-import { DEFAULT_CHART_HISTORY_LIMIT, createEmptySeries, normalizeStatistic } from "../charts.js";
-import { severityTrendDataAccessor } from "./accessors/severityTrendAccessor.js";
-import { statusTrendDataAccessor } from "./accessors/statusTrendAccessor.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, context, dataAccessor) => {
-    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), context.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, context) => {
-    const newOptions = { limit: DEFAULT_CHART_HISTORY_LIMIT, ...options };
-    const { dataType } = newOptions;
-    if (dataType === ChartDataType.Status) {
-        return generateTrendChartGeneric(newOptions, storeData, context, statusTrendDataAccessor);
-    }
-    else if (dataType === ChartDataType.Severity) {
-        return generateTrendChartGeneric(newOptions, storeData, context, severityTrendDataAccessor);
-    }
-};

package/dist/charts/pie.d.ts

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

package/dist/charts/pie.js

@@ -1,10 +0,0 @@
-import { getPieChartValues } from "@allurereport/core-api";
-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

@@ -1,6 +0,0 @@
-import type { TreeData, TreeGroup, TreeLeaf, TreeMapNode, WithChildren } from "@allurereport/core-api";
-import type { AllureChartsStoreData, TreeMapChartData, TreeMapChartOptions, TreeMapDataAccessor } from "../charts.js";
-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

@@ -1,88 +0,0 @@
-import { TreeMapChartType } from "@allurereport/core-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.d.ts

@@ -1,130 +0,0 @@
-import type { BarChartType, BarGroup, BarGroupMode, BaseTrendSliceMetadata, ChartDataType, ChartId, ChartMode, ChartType, HeatMapSerie, HistoryDataPoint, HistoryTestResult, PieSlice, SeverityLevel, Statistic, TestResult, TestStatus, TreeMapChartType, TreeMapNode, TrendPoint, TrendPointId, TrendSlice, TrendSliceId } from "@allurereport/core-api";
-export type ExecutionIdFn = (executionOrder: number) => string;
-export type ExecutionNameFn = (executionOrder: number) => string;
-export type TrendMetadataFnOverrides = {
-    executionIdAccessor?: ExecutionIdFn;
-    executionNameAccessor?: ExecutionNameFn;
-};
-export type TrendDataType = TestStatus | SeverityLevel;
-export type TrendStats<T extends TrendDataType> = Record<T, number>;
-export type TrendCalculationResult<T extends TrendDataType> = {
-    points: Record<TrendPointId, TrendPoint>;
-    series: Record<T, TrendPointId[]>;
-};
-export interface GenericTrendChartData<SeriesType extends string, Metadata extends BaseTrendSliceMetadata = BaseTrendSliceMetadata> {
-    type: ChartType.Trend;
-    dataType: ChartDataType;
-    mode: ChartMode;
-    title?: string;
-    points: Record<TrendPointId, TrendPoint>;
-    slices: Record<TrendSliceId, TrendSlice<Metadata>>;
-    series: Record<SeriesType, TrendPointId[]>;
-    min: number;
-    max: number;
-}
-export type StatusTrendChartData = GenericTrendChartData<TestStatus>;
-export type SeverityTrendChartData = GenericTrendChartData<SeverityLevel>;
-export type TrendChartData = StatusTrendChartData | SeverityTrendChartData;
-export interface BarChartData {
-    type: ChartType.Bar;
-    dataType: BarChartType;
-    mode: ChartMode;
-    title?: string;
-    data: BarGroup<string, string>[];
-    keys: readonly string[];
-    indexBy: string;
-    groupMode: BarGroupMode;
-}
-export interface TreeMapChartData {
-    type: ChartType.TreeMap;
-    dataType: TreeMapChartType;
-    title?: string;
-    treeMap: TreeMapNode;
-}
-export interface HeatMapChartData<T extends Record<string, any> = {}> {
-    type: ChartType.HeatMap;
-    title?: string;
-    data: HeatMapSerie<T>[];
-}
-export interface PieChartData {
-    type: ChartType.Pie;
-    title?: string;
-    slices: PieSlice[];
-    percentage: number;
-}
-export interface ComingSoonChartData {
-    type: ChartType.ComingSoon;
-    title?: string;
-}
-export type GeneratedChartData = TrendChartData | PieChartData | BarChartData | ComingSoonChartData | TreeMapChartData | HeatMapChartData;
-export type GeneratedChartsData = Record<ChartId, GeneratedChartData>;
-export type TrendChartOptions = {
-    type: ChartType.Trend;
-    dataType: ChartDataType;
-    mode?: ChartMode;
-    title?: string;
-    limit?: number;
-    metadata?: TrendMetadataFnOverrides;
-};
-export type PieChartOptions = {
-    type: ChartType.Pie;
-    title?: string;
-};
-export type BarChartOptions = {
-    type: ChartType.Bar;
-    dataType: BarChartType;
-    mode?: ChartMode;
-    title?: string;
-    limit?: number;
-};
-export type TreeMapChartOptions = {
-    type: ChartType.TreeMap;
-    dataType: TreeMapChartType;
-    title?: string;
-};
-export type HeatMapChartOptions = {
-    type: ChartType.HeatMap;
-    title?: string;
-};
-export type ComingSoonChartOptions = {
-    type: ChartType.ComingSoon;
-    title?: string;
-};
-export type ChartOptions = TrendChartOptions | PieChartOptions | BarChartOptions | ComingSoonChartOptions | TreeMapChartOptions | HeatMapChartOptions;
-export interface AllureChartsStoreData {
-    historyDataPoints: HistoryDataPoint[];
-    testResults: TestResult[];
-    statistic: Statistic;
-}
-export interface TrendDataAccessor<T extends TrendDataType> {
-    getCurrentData: (storeData: AllureChartsStoreData) => TrendStats<T>;
-    getHistoricalData: (historyPoint: HistoryDataPoint) => TrendStats<T>;
-    getAllValues: () => readonly T[];
-}
-export interface BarDataAccessor<G extends string, T extends string> {
-    getItems: (storeData: AllureChartsStoreData, limitedHistoryDataPoints: HistoryDataPoint[], isFullHistory: boolean) => BarGroup<G, T>[];
-    getGroupKeys: () => readonly T[];
-    getGroupMode: () => BarGroupMode;
-}
-export interface TreeMapDataAccessor<T extends TreeMapNode> {
-    getTreeMap: (storeData: AllureChartsStoreData) => T;
-}
-export interface HeatMapDataAccessor<T extends Record<string, unknown> = {}> {
-    getHeatMap: (storeData: AllureChartsStoreData) => HeatMapSerie<T>[];
-}
-export declare const DEFAULT_CHART_HISTORY_LIMIT = 10;
-export declare const limitHistoryDataPoints: (historyDataPoints: HistoryDataPoint[], limit: number) => HistoryDataPoint[];
-export declare const createEmptySeries: <T extends string>(items: readonly T[]) => Record<T, string[]>;
-export declare const createEmptyStats: <T extends string>(items: readonly T[]) => Record<T, number>;
-export declare const normalizeStatistic: <T extends string>(statistic: Partial<Record<T, number>>, itemType: readonly T[]) => Record<T, number>;
-export declare const hasLabels: <T extends string, TR extends TestResult | HistoryTestResult>(test: TR, labelHierarchy: T[]) => boolean;
-export declare const isChildrenLeavesOnly: <T extends TreeMapNode>(node: T) => boolean;
-export declare const defaultChartsConfig: ({
-    type: string;
-    title: string;
-    dataType?: undefined;
-} | {
-    type: string;
-    dataType: string;
-    title: string;
-})[];