public static converter()

in src/columnChart/baseColumnChart.ts [345:487]
122 lines of code
11 McCabe index (conditional complexity)

    public static converter(
        visualHost: IVisualHost,
        categorical: DataViewCategorical,
        colors: IColorPalette,
        is100PercentStacked: boolean = false,
        isScalar: boolean = false,
        supportsOverflow: boolean = false,
        dataViewMetadata: DataViewMetadata = null,
        localizationManager: ILocalizationManager,
        chartType?: MekkoVisualChartType): MekkoColumnChartData {

        const xAxisCardProperties: powerbi.DataViewObject = dataViewUtils.getCategoryAxisProperties(dataViewMetadata);
        const valueAxisProperties: powerbi.DataViewObject = dataViewUtils.getValueAxisProperties(dataViewMetadata);

        isScalar = dataViewUtils.isScalar(isScalar, xAxisCardProperties);
        categorical = utils.applyUserMinMax(isScalar, categorical, xAxisCardProperties);

        const converterStrategy: BaseConverterStrategy =
            new BaseConverterStrategy(categorical, visualHost);

        const firstCategory: DataViewCategoryColumn = categorical
            && categorical.categories
            && categorical.categories[0],
            categories: PrimitiveValue[] = firstCategory
                ? firstCategory.values
                : [],
            categoryIdentities: CustomVisualOpaqueIdentity[] = firstCategory
                ? firstCategory.identity
                : [],
            categoryMetadata: DataViewMetadataColumn = firstCategory
                ? firstCategory.source
                : undefined;

        const categoryFormatter: IValueFormatter = valueFormatter.create({
            format: valueFormatter.getFormatStringByColumn(categoryMetadata),
            value: categories[0],
            value2: categories[categories.length - 1],
            displayUnitSystemType: DisplayUnitSystemType.Verbose
        });

        let borderSettings: MekkoBorderSettings = MekkoChart.DefaultSettings.columnBorder,
            sortSeriesSettings: MekkoSeriesSortSettings = MekkoChart.DefaultSettings.sortSeries,
            sortLegendSettings: MekkoLegendSortSettings = MekkoChart.DefaultSettings.sortLegend,
            xAxisLabelsSettings: MekkoXAxisLabelsSettings = MekkoChart.DefaultSettings.xAxisLabels,
            categoryColumnSettings: MekkoCategoryColorSettings = MekkoChart.DefaultSettings.categoryColor,
            labelSettings: VisualDataLabelsSettings = dataLabelUtils.getDefaultColumnLabelSettings(true),
            dataPointSettings: MekkoDataPointSettings = MekkoChart.DefaultSettings.dataPoint;

        let defaultDataPointColor: string = undefined,
            showAllDataPoints: boolean = undefined;

        if (dataViewMetadata && dataViewMetadata.objects) {
            const objects: powerbi.DataViewObjects = dataViewMetadata.objects;

            defaultDataPointColor = dataViewObjects.getFillColor(
                objects,
                MekkoChart.Properties["dataPoint"]["defaultColor"]);

            showAllDataPoints = dataViewObjects.getValue<boolean>(
                objects,
                MekkoChart.Properties["dataPoint"]["showAllDataPoints"]);

            labelSettings = MekkoChart.parseLabelSettings(objects);
            borderSettings = MekkoChart.parseBorderSettings(objects);
            sortLegendSettings = MekkoChart.parseLegendSortSettings(objects);
            sortSeriesSettings = MekkoChart.parseSeriesSortSettings(objects);
            xAxisLabelsSettings = MekkoChart.parseXAxisLabelsSettings(objects);
            dataPointSettings = MekkoChart.parseDataPointSettings(objects);
        }

        // Allocate colors
        let legendAndSeriesInfo: LegendSeriesInfo = converterStrategy.getLegend(colors, defaultDataPointColor, "", dataPointSettings.categoryGradient, dataPointSettings.colorGradientEndColor.solid.color);
        let legend: MekkoLegendDataPoint[] = legendAndSeriesInfo.legend.dataPoints;

        let seriesSources: DataViewMetadataColumn[] = legendAndSeriesInfo.seriesSources;

        // Determine data points
        let result: MekkoDataPoints = BaseColumnChart.createDataPoints(
            visualHost,
            categorical,
            categories,
            categoryIdentities,
            legend,
            legendAndSeriesInfo.seriesObjects,
            converterStrategy,
            labelSettings,
            is100PercentStacked,
            isScalar,
            supportsOverflow,
            localizationManager,
            converterHelper.categoryIsAlsoSeriesRole(
                categorical,
                RoleNames.series,
                RoleNames.category),
            firstCategory && firstCategory.objects,
            defaultDataPointColor,
            chartType,
            categoryMetadata);

        if (sortSeriesSettings.enabled) {
            let columns = BaseColumnChart.createAlternateStructure(result, sortSeriesSettings.direction === "des");
            BaseColumnChart.reorderPositions(result, columns);
        }

        const valuesMetadata: DataViewMetadataColumn[] = [];

        for (let j: number = 0; j < legend.length; j++) {
            valuesMetadata.push(seriesSources[j]);
        }

        const labels: axisUtils.AxesLabels = axisUtils.createAxesLabels(
            xAxisCardProperties,
            valueAxisProperties,
            categoryMetadata,
            valuesMetadata);

        return {
            categories,
            categoryFormatter,
            defaultDataPointColor,
            showAllDataPoints,
            categoryMetadata,
            categoriesWidth: result.categoriesWidth,
            borderSettings,
            sortlegend: sortLegendSettings,
            sortSeries: sortSeriesSettings,
            xAxisLabelsSettings: xAxisLabelsSettings,
            labelSettings,
            series: result.series,
            valuesMetadata,
            legendData: legendAndSeriesInfo.legend,
            hasHighlights: result.hasHighlights,
            scalarCategoryAxis: isScalar,
            axesLabels: {
                x: labels.xAxisLabel,
                y: labels.yAxisLabel
            },
            hasDynamicSeries: result.hasDynamicSeries,
            categoryProperties: result.categoryProperties,
            isMultiMeasure: false,
            dataPointSettings: dataPointSettings
        };
    }