@ministryofjustice/hmpps-digital-prison-reporting-frontend/dpr/components/_dashboards/dashboard-section/utils.js

The Digital Prison Reporting Frontend contains templates and code to help display data effectively in UI applications.

import ChartUtils from '../../_charts/utils.js';
import DashboardListUtils from '../dashboard-list/utils.js';
import { DashboardVisualisationType } from '../dashboard-visualisation/types.js';
import { getFeatureFlagVisTypeMap } from '../dashboard-visualisation/utils.js';
import { ScorecardGroupVisualisation } from '../scorecard-group/ScorecardGroup.js';
import { ScorecardVisualisation } from '../scorecard/Scorecard.js';
import ScorecardsUtils from '../scorecard/utils.js';

const createDashboardSections = (dashboardDefinition, dashboardData, parentChildData, query, dashboardFeatureFlags, partialDate) => {
    return dashboardDefinition.sections.map((section) => {
        const { id, display: title, description } = section;
        const featureFlagVisTypeMap = getFeatureFlagVisTypeMap(dashboardFeatureFlags);
        let hasScorecard = false;
        const visualisations = section.visualisations.map((visDefinition) => {
            const { type, variantId, display, description: visDescription, id: visId } = visDefinition;
            const isEnabled = featureFlagVisTypeMap[type];
            const dashboardDataForVis = parentChildData.find(data => data.id === variantId)?.data || dashboardData;
            let chartData;
            switch (type) {
                case DashboardVisualisationType.LIST:
                    chartData = DashboardListUtils.createList(visDefinition, dashboardDataForVis);
                    break;
                case DashboardVisualisationType.SCORECARD:
                    hasScorecard = true;
                    chartData = new ScorecardVisualisation().withDefinition(visDefinition).withData(dashboardDataForVis).build();
                    break;
                case DashboardVisualisationType.SCORECARD_GROUP:
                    chartData = new ScorecardGroupVisualisation()
                        .withDefinition(visDefinition)
                        .withData(dashboardDataForVis)
                        .build();
                    break;
                case DashboardVisualisationType.BAR:
                case DashboardVisualisationType.LINE:
                case DashboardVisualisationType.DONUT: {
                    chartData = ChartUtils.createChart(visDefinition, dashboardDataForVis, type);
                    break;
                }
                case DashboardVisualisationType.MATRIX_TIMESERIES:
                case DashboardVisualisationType.BAR_TIMESERIES:
                case DashboardVisualisationType.LINE_TIMESERIES: {
                    chartData = ChartUtils.createTimeseriesCharts(visDefinition, dashboardDataForVis, type, query, partialDate);
                    break;
                }
            }
            return {
                id: visId,
                title: display || '',
                description: visDescription || '',
                type,
                data: chartData,
                isEnabled: isEnabled ?? true,
            };
        });
        if (hasScorecard)
            ScorecardsUtils.mergeScorecardsIntoGroup(visualisations, featureFlagVisTypeMap[DashboardVisualisationType.SCORECARD_GROUP]);
        return { id, title: title || '', description: description || '', visualisations };
    });
};
/**
 * Add variant ID to section
 *
 * @param {components['schemas']['DashboardSectionDefinition']} section
 * @param {string} variantId
 * @return {*}  {components['schemas']['DashboardSectionDefinition']}
 */
const addVariantIdToSection = (section, variantId) => ({
    ...section,
    visualisations: section.visualisations.map(visualisation => ({
        ...visualisation,
        variantId,
    })),
});
/**
 * Builds a master section collection from a parent dashboard and its child variants.
 *
 * @param {DashboardDefinition} definition
 * @return {*}  {components['schemas']['DashboardSectionDefinition'][]}
 */
const buildMasterSections = (definition) => {
    const parentSections = definition.sections.map(section => addVariantIdToSection(section, definition.id));
    return definition.childVariants.reduce((sections, childVariant) => childVariant.sections
        .map(section => addVariantIdToSection(section, childVariant.id))
        .reduce(mergeSection, sections), parentSections);
};
/**
 * Merges the sections
 *
 * Rules:
 * - Parent sections are added first and retain their original order.
 * - Child variants are processed in array order.
 * - Child sections are processed in section order within each variant.
 * - If a child section ID matches an existing section ID, its visualisations are appended to that section.
 * - If a child section ID does not exist, the section is appended to the end of the collection.
 * - Visualisation order is preserved as defined in the source section
 *
 * @param {components['schemas']['DashboardSectionDefinition'][]} sections
 * @param {components['schemas']['DashboardSectionDefinition']} section
 * @return {*}
 */
const mergeSection = (sections, section) => {
    const existingIndex = sections.findIndex(existing => existing.id === section.id);
    if (existingIndex === -1) {
        return [...sections, section];
    }
    return sections.map((existing, index) => index === existingIndex
        ? {
            ...existing,
            visualisations: [...existing.visualisations, ...section.visualisations],
        }
        : existing);
};

export { addVariantIdToSection, buildMasterSections, createDashboardSections };
//# sourceMappingURL=utils.js.map