public static CONVERTER()

in src/TornadoChart.ts [189:293]
95 lines of code
18 McCabe index (conditional complexity)

    public static CONVERTER( 
        dataView: DataView,
        hostService: IVisualHost,
        textOptions: TornadoChartTextOptions,
        colors: IColorPalette,
        localizationManager: ILocalizationManager
    ): TornadoChartDataView {
        let categorical: DataViewCategorical = dataView.categorical;
        let categories: DataViewCategoryColumn[] = categorical.categories || [];
        let values: DataViewValueColumns = categorical.values;
        let category: DataViewCategoryColumn = categories[0];
        let maxValue: number = d3.max(<number[]>values[0].values);
        let minValue: number = Math.min(d3.min(<number[]>values[0].values), 0);
        if (values.length >= TornadoChart.MaxSeries) {
            minValue = d3.min([minValue, d3.min(<number[]>values[1].values)]);
            maxValue = d3.max([maxValue, d3.max(<number[]>values[1].values)]);
        }
        let settings: TornadoChartSettings = TornadoChart.parseSettings(dataView.metadata.objects, maxValue, colors);
        let hasDynamicSeries: boolean = !!values.source;
        let hasHighlights: boolean = values.length > 0 && values.some(value => value.highlights && value.highlights.some(_ => _));
        let labelHeight: number = textMeasurementService.estimateSvgTextHeight({
            fontFamily: dataLabelUtils.StandardFontFamily,
            fontSize: PixelConverter.fromPoint(settings.labelSettings.fontSize),
        });
        let series: TornadoChartSeries[] = [];
        let dataPoints: TornadoChartPoint[] = [];
        let highlightedDataPoints: TornadoChartPoint[] = [];
        let categorySourceFormatter: IValueFormatter = valueFormatter.create({
            format: valueFormatter.getFormatStringByColumn(category.source)
        });
        let categoriesLabels: TextData[] = category.values.map(value => TornadoChart.getTextData(categorySourceFormatter.format(value), textOptions, true));
        let groupedValues: DataViewValueColumnGroup[] = values.grouped ? values.grouped() : null;

        for (let seriesIndex = 0; seriesIndex < Math.min(values.length, TornadoChart.MaxSeries); seriesIndex++) {
            let columnGroup: DataViewValueColumnGroup = groupedValues && groupedValues.length > seriesIndex
                && groupedValues[seriesIndex].values ? groupedValues[seriesIndex] : null;
            let parsedSeries: TornadoChartSeries = TornadoChart.PARSE_SERIES(dataView, values, hostService, seriesIndex, hasDynamicSeries, columnGroup, colors);
            let currentSeries: DataViewValueColumn = values[seriesIndex];
            let measureName: string = currentSeries.source.queryName;

            series.push(parsedSeries);

            for (let i: number = 0; i < category.values.length; i++) {
                let value: number = currentSeries.values[i] == null || isNaN(<number>currentSeries.values[i]) ? 0 : <number>currentSeries.values[i];
                let identity: ISelectionId = TornadoChart.buildIdentitySelection(hostService, category, i, values, columnGroup, measureName);
                let formattedCategoryValue: string = categoriesLabels[i].text;

                const buildTooltip = (highlightedValue) => tooltipBuilder.createTooltipInfo(
                        categorical,
                        formattedCategoryValue,
                        localizationManager,
                        value,
                        seriesIndex,
                        highlightedValue || null);

                // Limit maximum value with what the user choose
                let currentMaxValue = parsedSeries.categoryAxisEnd ? parsedSeries.categoryAxisEnd : maxValue;
                let formatString: string = dataView.categorical.values[seriesIndex].source.format;
                let highlight: number = null;
                const dataPointCommon = {
                    value,
                    minValue,
                    maxValue: currentMaxValue,
                    formatString,
                    color: parsedSeries.fill,
                    selected: false,
                    identity,
                    categoryIndex: i,
                };

                if (hasHighlights) {
                    highlight = <number>currentSeries.highlights[i];
                    let highlightedValue: number = highlight != null ? highlight : value;

                    highlightedDataPoints.push({
                        ...dataPointCommon,
                        value: highlightedValue,
                        tooltipData: buildTooltip(highlightedValue),
                        highlight: !!highlight,
                    });
                }

                dataPoints.push({
                    ...dataPointCommon,
                    tooltipData: buildTooltip(null),
                    highlight: hasHighlights && !!highlight,
                });
            }
        }

        return {
            categories: categoriesLabels,
            series: series,
            settings: settings,
            legend: TornadoChart.getLegendData(series, hasDynamicSeries),
            dataPoints: dataPoints,
            highlightedDataPoints: highlightedDataPoints,
            maxLabelsWidth: Math.max(...categoriesLabels.map(x => x.width)),
            hasDynamicSeries: hasDynamicSeries,
            hasHighlights: hasHighlights,
            labelHeight: labelHeight,
            legendObjectProperties: dataViewObjects.getObject(dataView.metadata.objects, "legend", {}),
            categoriesObjectProperties: dataViewObjects.getObject(dataView.metadata.objects, "categories", {}),
        };
    }