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

package/dist/charts/bar.js

@@ -0,0 +1,50 @@
+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

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

package/dist/charts/comingSoon.js

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

package/dist/charts/heatmap.d.ts

@@ -0,0 +1,3 @@
+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

@@ -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/line.d.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,88 @@
+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,6 +1,4 @@
-import type { BaseTrendSliceMetadata, ChartId, ChartType, HistoryDataPoint, PieSlice, SeverityLevel, Statistic, TestResult, TestStatus, TrendPoint, TrendPointId, TrendSlice, TrendSliceId } from "@allurereport/core-api";
-import { ChartDataType, ChartMode } from "@allurereport/core-api";
-import type { PluginContext } from "./plugin.js";
+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 = {
@@ -8,6 +6,7 @@ export type TrendMetadataFnOverrides = {
     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[]>;
@@ -26,9 +25,39 @@ export interface GenericTrendChartData<SeriesType extends string, Metadata exten
 export type StatusTrendChartData = GenericTrendChartData<TestStatus>;
 export type SeverityTrendChartData = GenericTrendChartData<SeverityLevel>;
 export type TrendChartData = StatusTrendChartData | SeverityTrendChartData;
-export type GeneratedChartData = TrendChartData | PieChartData | ComingSoonChartData;
+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 TrendStats<T extends TrendDataType> = Record<T, number>;
 export type TrendChartOptions = {
     type: ChartType.Trend;
     dataType: ChartDataType;
@@ -41,45 +70,61 @@ export type PieChartOptions = {
     type: ChartType.Pie;
     title?: string;
 };
-export type ComingSoonChartOptions = {
-    type: ChartType.HeatMap | ChartType.Bar | ChartType.Funnel | ChartType.TreeMap;
+export type BarChartOptions = {
+    type: ChartType.Bar;
+    dataType: BarChartType;
+    mode?: ChartMode;
     title?: string;
+    limit?: number;
 };
-export type ChartOptions = TrendChartOptions | PieChartOptions | ComingSoonChartOptions;
-export interface PieChartData {
-    type: ChartType.Pie;
+export type TreeMapChartOptions = {
+    type: ChartType.TreeMap;
+    dataType: TreeMapChartType;
     title?: string;
-    slices: PieSlice[];
-    percentage: number;
-}
-export interface ComingSoonChartData {
-    type: ChartType.HeatMap | ChartType.Bar | ChartType.Funnel | ChartType.TreeMap;
+};
+export type HeatMapChartOptions = {
+    type: ChartType.HeatMap;
     title?: string;
-}
-export declare const createEmptySeries: <T extends TrendDataType>(items: readonly T[]) => Record<T, string[]>;
-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 createEmptyStats: <T extends TrendDataType>(items: readonly T[]) => TrendStats<T>;
-export declare const normalizeStatistic: <T extends TrendDataType>(statistic: Partial<TrendStats<T>>, itemType: readonly T[]) => TrendStats<T>;
-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 DEFAULT_CHART_HISTORY_LIMIT = 10;
-export declare const getPieChartData: (stats: Statistic, chartOptions: PieChartOptions) => PieChartData;
-export declare const generatePieChart: (options: PieChartOptions, stores: {
+};
+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;
-}) => PieChartData;
-export declare const generateComingSoonChart: (options: ComingSoonChartOptions) => ComingSoonChartData;
+}
 export interface TrendDataAccessor<T extends TrendDataType> {
-    getCurrentData: (trs: TestResult[], stats: Statistic) => TrendStats<T>;
+    getCurrentData: (storeData: AllureChartsStoreData) => TrendStats<T>;
     getHistoricalData: (historyPoint: HistoryDataPoint) => TrendStats<T>;
     getAllValues: () => readonly T[];
 }
-export declare const generateTrendChartGeneric: <T extends TrendDataType>(options: TrendChartOptions, stores: {
-    trs: TestResult[];
-    statistic: Statistic;
-    history: HistoryDataPoint[];
-}, context: PluginContext, dataAccessor: TrendDataAccessor<T>) => GenericTrendChartData<T> | undefined;
-export declare const generateTrendChart: (options: TrendChartOptions, stores: {
-    trs: TestResult[];
-    statistic: Statistic;
-    history: HistoryDataPoint[];
-}, context: PluginContext) => TrendChartData | undefined;
+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;
+})[];