function createFacetsData()

in src/data.ts [435:524]
67 lines of code
14 McCabe index (conditional complexity)

function createFacetsData(aggregatedData: AggregatedData, options: ConvertToFacetsVisualDataOptions) {
    const { colors, settings } = options;
    const normalFacetState = JSON.parse(settings.facetState.normalFacet);
    const colorPalette = colors ? COLOR_PALETTE.slice().concat(colors.map((color: IColorInfo) => color.value)) : COLOR_PALETTE.slice();
    const hasHighlight = aggregatedData.hasHighlight;
    const result = <FacetGroup[]>[];

    let maxFacetInstanceCount = 0;

    Object.keys(aggregatedData.dataPointsMap).forEach((key: string) => {
        const dataPoints = aggregatedData.dataPointsMap[key];

        const facets: Facet[] = [];
        const prependedSelectedFacets: Facet[] = [];
        const facetGroup: FacetGroup = {
            label: dataPoints[0].facetLabel,
            key: key,
            facets: [], // initial facet
            more: 0,
            total: 0,

            allFacets: [],
            order: (normalFacetState[key] && normalFacetState[key].order) || 0,
            collapsed: !!normalFacetState[key] && !!normalFacetState[key].collapsed,
        };
        const facetGroupColor = colorPalette.shift();
        const opacities = [100, 60, 35];

        dataPoints
            .sort((a: DataPoint, b: DataPoint) => b.instanceCount - a.instanceCount || a.instanceLabel.localeCompare(b.instanceLabel))
            .forEach((dp: DataPoint) => {
                const {
                    highlight,
                    instanceValue,
                    instanceLabel,
                    instanceCount,
                    instanceCountFormatter,
                    instanceColor,
                    instanceIconClass,
                    bucket,
                    sparklineData,
                } = dp;
                const nextColorOpacity = opacities.shift();
                const defaultColor = facetGroupColor && nextColorOpacity && hexToRgba(facetGroupColor, nextColorOpacity);
                const facetColor = instanceColor || defaultColor || '#DDDDDD';
                const useDataPoint = hasHighlight ? !!highlight : true;
                const facet: Facet = {
                    icon: {
                        class: instanceIconClass,
                        color: facetColor,
                    },
                    count: instanceCount,
                    countLabel: formatValue(instanceCountFormatter, instanceCount, ''),
                    value: instanceValue,
                    timeseries: sparklineData ? createTimeSeries(aggregatedData.sparklineXDomain, sparklineData) : undefined,
                    label: instanceLabel,
                };

                // add segments if there is bucket
                if (bucket) {
                    const segmentsBaseColor = instanceColor || hexToRgba(facetGroupColor, 100);
                    dp.selectionColor = { color: segmentsBaseColor, opacity: 100 };
                    facet['segments'] = createSegments(bucket, segmentsBaseColor, false);
                    facet.icon.color = getSegmentColor(segmentsBaseColor, 100, 0, 1, false);
                }

                isInSelectedDataPoints(dp, aggregatedData.selectedDataPoints)
                    ? prependedSelectedFacets.push(facet)
                    : useDataPoint && facets.push(facet);

                maxFacetInstanceCount = Math.max(maxFacetInstanceCount, instanceCount);
            });
        // prepend selected facets to the facets array
        facets.unshift(...prependedSelectedFacets);

        // Limit the number of facets to display
        const initialNumFacets = Math.max(settings.facetCount.initial, prependedSelectedFacets.length);
        const remainingFacetsCount = Math.max(facets.length - initialNumFacets, 0);
        facetGroup.facets = facets.slice(0, initialNumFacets);
        facetGroup.more = remainingFacetsCount && [
            { label: otherLabelTemplate(remainingFacetsCount), class: 'other', clickable: false },
            { label: 'More', class: 'more', clickable: true },
        ];
        facetGroup.allFacets = facets;

        facets.length > 0 && result.push(facetGroup);
    });
    result.forEach((group: FacetGroup) => group.total = maxFacetInstanceCount);
    return result;
}