public static CONVERTER()

in src/visual.ts [257:361]
83 lines of code
8 McCabe index (conditional complexity)

    public static CONVERTER(
        dataView: DataView,
        visualHost: IVisualHost,
        localizationManager: ILocalizationManager,
        colorHelper: ColorHelper
    ): HistogramData {

        let settings: HistogramSettings,
            categoryColumn: DataViewCategoryColumn = dataView.categorical.categories[0],
            numericalValues: number[] = [],
            bins: LayoutBin[],
            dataPoints: HistogramDataPoint[],
            frequencies: number[] = [],
            sumFrequency: number = Default.SumFrequency,
            borderValues: HistogramBorderValues,
            sourceValues: number[] = <number[]>categoryColumn.values;

        settings = Visual.parseSettings(dataView, colorHelper);

        if (!settings
            || !Visual.ARE_VALUES_NUMBERS(categoryColumn)
            || sourceValues.length < Default.MinAmountOfValues
        ) {
            return null;
        }

        frequencies = Visual.GET_FREQUENCIES(dataView.categorical);

        let values:  HistogramValue[] = Visual.getValuesByFrequencies(
            visualHost,
            categoryColumn,
            sourceValues,
            frequencies
        );

        values.forEach((value: HistogramValue) => {
            numericalValues.push(value.value);
            sumFrequency += value.frequency;
        });

        const [min, max] = d3.extent(numericalValues);

        const binsCount: number =
            (settings.general.bins && settings.general.bins > HistogramGeneralSettings.MinNumberOfBins)
            ? settings.general.bins
            : d3.histogram()(numericalValues).length; // predict bins count for interval correction
        const interval: number = (max - min) / binsCount;

        bins = d3.histogram().thresholds(
            d3.range(min, max, interval)
        )(numericalValues);

        bins.forEach((bin: LayoutBin, index: number) => {
            let filteredValues: HistogramValue[],
                frequency: number;

            filteredValues = values.filter((value: HistogramValue) => {
                return Visual.isValueContainedInRange(value, bin, index);
            });

            frequency = filteredValues.reduce((previousValue: number, currentValue: HistogramValue): number => {
                return previousValue + currentValue.frequency;
            }, 0);

            bin.y = settings.general.frequency
                ? frequency
                : frequency / sumFrequency;
            });

        borderValues = Visual.GET_BORDER_VALUES(bins);

        // min-max for Y axis
        Visual.getMinMaxFoxYAxis(settings.yAxis, borderValues);

        // min-max for X axis
        Visual.setMinMaxForXAxis(settings.xAxis, borderValues);

        // formatters
        let formatters: { valueFormatter?: IValueFormatter, xLabelFormatter?: IValueFormatter, yLabelFormatter?: IValueFormatter } = {};
        if (values.length >= Default.MinAmountOfValues) {
            formatters = Visual.createFormatters(dataView, values, settings);
        }

        dataPoints = Visual.getDataPoints(
            values,
            bins,
            settings,
            formatters.yLabelFormatter,
            formatters.xLabelFormatter,
            localizationManager
        );

        return {
            dataPoints,
            borderValues,
            settings,
            xLabelFormatter: formatters.xLabelFormatter,
            yLabelFormatter: formatters.yLabelFormatter,
            formatter: formatters.valueFormatter,
            xLegendSize: Visual.getLegendSize(settings.xAxis),
            yLegendSize: Visual.getLegendSize(settings.yAxis),
            xCorrectedMin: null,
            xCorrectedMax: null
        };
    }