function visualTransform()

in src/barChart.ts [168:403]
74 lines of code
11 McCabe index (conditional complexity)

function visualTransform(options: VisualUpdateOptions, host: IVisualHost): IBarChartViewModel {
    let dataViews = options.dataViews;

    let defaultSettings: IBarChartSettings = {

        alignBarLabels: {
            show: false,
        },
        barHeight: {
            height: 30,
            show: true,
        },
        barShape: {
            headColor: { solid: { color: "#FEA19E" } },
            labelPosition: "Top",
            shape: "Bar",
        },
        clearFilters: {
            show: false,
        },
        experimental: {
            blendMode: "difference",
            show: false,
        },
        fontParams: {
            fontSize: 11,
            show: false,
        },
        generalView: {
            barHeight: 30,
            barsColor: { solid: { color: "turquoise" } },
            minHeight: 250,
            opacity: 100,
            overlapColor: { solid: { color: "#FEA19E" } },
            textColor: { solid: { color: "#000" } },
        },
        showBarLabels: {
            highlightColor: { solid: { color: "#000" } },
            show: true,
            textColor: { solid: { color: "#FFF" } },
        },
        units: {
            decimalPlaces: null,
            tooltipUnits: 0,
        },
    };
    let viewModel: IBarChartViewModel = {
        dataMax: 0,
        dataPoints: [],
        settings: <IBarChartSettings> {},
        widthMax: 0,
    };

    if (!dataViews
        || !dataViews[0]
        || !dataViews[0].categorical
        || !dataViews[0].categorical.categories
        || !dataViews[0].categorical.categories[0].source
        || !dataViews[0].categorical.values) {
        return viewModel;
    }

    let categorical = dataViews[0].categorical;
    let category = categorical.categories[0];
    let dataValue = categorical.values[0];
    let metadata = dataViews[0].metadata;

    let overlapDataValue = [];

    let overlapIndex = getOverlapIndex(metadata);

    if (overlapIndex !== -1) {
        overlapDataValue = getDataValueForOverlapValue(categorical.values, overlapIndex);
    }

    let tooltipData = categorical.values.slice(1, categorical.values.length);

    let valueFormatterForCategories: IValueFormatter = valueFormatter.valueFormatter.create({
        format: valueFormatter.valueFormatter.getFormatStringByColumn(category.source),
        value: dataValue,
        value2: categorical.values[categorical.values.length - 1],
    });

    let IBarChartDataPoints: IBarChartDataPoint[] = [];
    let dataMax: number;
    let lenMax: number = 0;
    let currTextWidth: number = 0;
    let colorPalette: IColorPalette = host.colorPalette;

    let objects = metadata.objects;

    let textProperties: ITextProperties;

    let IBarChartSettings: IBarChartSettings = {
        alignBarLabels: {
            show: getValue<boolean> (objects, "alignBarLabels", "show",
                defaultSettings.alignBarLabels.show),
        },
        barHeight: {
            height: getValue<number> (objects, "barHeight", "height",
                defaultSettings.barHeight.height),
            show: getValue<boolean> (objects, "barHeight", "show",
                defaultSettings.barHeight.show),
        },
        barShape: {
            headColor: getValue<string> (objects, "barShape", "headColor",
                defaultSettings.barShape.headColor),
            labelPosition: getValue<string> (objects, "barShape", "labelPosition",
                defaultSettings.barShape.labelPosition),
            shape: getValue<string> (objects, "barShape", "shape",
                defaultSettings.barShape.shape),
        },
        clearFilters: {
            show: getValue<boolean> (objects, "clearFilters", "show",
                defaultSettings.clearFilters.show),
        },
        experimental: {
            blendMode: getValue<string> (objects, "experimental", "blendMode",
                defaultSettings.experimental.blendMode),
            show: getValue<boolean> (objects, "experimental", "show",
                defaultSettings.experimental.show),
        },
        fontParams: {
            fontSize: getValue<number> (objects, "fontParams", "fontSize",
                defaultSettings.fontParams.fontSize),
            show: getValue<boolean> (objects, "fontParams", "show",
                defaultSettings.fontParams.show),
        },
        generalView: {
            barHeight: getValue<number> (objects, "generalView", "barHeight", defaultSettings.generalView.barHeight),
            barsColor: getValue<string> (objects, "generalView", "barsColor", defaultSettings.generalView.barsColor),
            minHeight: getValue<number> (objects, "generalView", "minHeight", defaultSettings.generalView.minHeight),
            opacity: getValue<number> (objects, "generalView", "opacity", defaultSettings.generalView.opacity),
            overlapColor: getValue<string> (objects, "generalView", "overlapColor",
                defaultSettings.generalView.overlapColor),
            textColor: getValue<string> (objects, "generalView", "textColor",
                defaultSettings.generalView.textColor),
        },
        showBarLabels: {
            highlightColor: getValue<string> (objects, "showBarLabels", "highlightColor",
            defaultSettings.showBarLabels.highlightColor),
            show: getValue<boolean> (objects, "showBarLabels", "show",
            defaultSettings.showBarLabels.show),
            textColor: getValue<string> (objects, "showBarLabels", "textColor",
            defaultSettings.showBarLabels.textColor),
        },
        units: {
            decimalPlaces: getValue<number> (objects, "units", "decimalPlaces",
                defaultSettings.units.decimalPlaces),
            tooltipUnits: getValue<number> (objects, "units", "tooltipUnits",
                defaultSettings.units.tooltipUnits),
        },

    };

    for (let i = 0, len = Math.max(category.values.length, dataValue.values.length); i < len; i++) {
        let defaultColor: Fill = {
            solid: {
                color: colorPalette.getColor(category.values[i] + "").value,
            },
        };

        valueFormatterForCategories = valueFormatter.valueFormatter.create({
            format: valueFormatter.valueFormatter.getFormatStringByColumn(metadata.columns[i]),
            value: dataValue,
            value2: categorical.values[categorical.values.length - 1],
        });

        let tooltip = [];
        let index;

        for (let tooltipDataItem of tooltipData) {
        // for (let j = 0; j < tooltipData.length; j++) {

            index = getMetadataIndexFor(tooltipDataItem.source.displayName, metadata.columns);

            valueFormatterForCategories = valueFormatter.valueFormatter.create({
                format: valueFormatter.valueFormatter.getFormatStringByColumn(metadata.columns[index]),
                value: dataValue,
                value2: categorical.values[categorical.values.length - 1],
            });
            tooltip.push({
                displayName: tooltipDataItem.source.displayName,
                value: valueFormatterForCategories.format(tooltipDataItem.values[i]),
            });
        }

        let format = valueFormatter.valueFormatter.getFormatStringByColumn(
            metadata.columns[getMetadataIndexFor(
                categorical.values[0].source.displayName, metadata.columns)]);

        valueFormatterForCategories = valueFormatter.valueFormatter.create({
            format,
            value: dataValue,
            value2: categorical.values[categorical.values.length - 1],
        });

        textProperties = {
            fontFamily: "Segoe UI",
            fontSize: IBarChartSettings.fontParams.fontSize + "px",
            text: valueFormatterForCategories.format(category.values[i]),
        };
        currTextWidth = textMeasurementService.textMeasurementService.measureSvgTextWidth(textProperties);

        IBarChartDataPoints.push({
            category: category.values[i] + "",
            color: getCategoricalObjectValue<Fill> (category, i, "colorSelector", "fill", defaultColor).solid.color,
            currTextWidth,
            formattedOverlapValue: "",
            formattedValue: valueFormatterForCategories.format(dataValue.values[i]),
            overlapValue: overlapDataValue.length > 0 ? overlapDataValue[i] : null,

            precision: formattingService.numberFormat.isStandardFormat(format) === false ?
                formattingService.numberFormat.getCustomFormatMetadata(format, true).precision : null,
            selected: false,
            selectionId: host.createSelectionIdBuilder()
                .withCategory(category, i)
                .createSelectionId(),
            tooltip,
            value: dataValue.values[i],
            width: null,

        });

    }
    let overlapDataValueMax = Math.max.apply(Math, overlapDataValue);

    dataMax = <number> dataValue.maxLocal <= overlapDataValueMax ? overlapDataValueMax : dataValue.maxLocal;

    return {
        dataMax,
        dataPoints: IBarChartDataPoints,
        settings: IBarChartSettings,
        widthMax: lenMax,
    };
}