private static converter()

in src/visual.ts [340:463]
103 lines of code
24 McCabe index (conditional complexity)

    private static converter(
        dataView: DataView,
        visualHost: IVisualHost,
        localizationManager: ILocalizationManager,
        colorHelper: ColorHelper,
    ): LineDotChartViewModel {
        let categorical: LineDotChartColumns<DataViewCategoryColumn & DataViewValueColumn[]>
            = LineDotChartColumns.getCategoricalColumns(dataView);

        if (!categorical
            || !categorical.Date
            || !categorical.Date.source
            || _.isEmpty(categorical.Date.values)
            || !categorical.Values
            || !categorical.Values[0]
            || !categorical.Values[0].source
            || _.isEmpty(categorical.Values[0].values)) {
            return null;
        }

        let counterValues: PrimitiveValue[] = null;

        for (let i = 0; i < dataView.categorical.values.length; i++) {
            if (dataView.categorical.values[i].source.roles["Counter"]) {
                counterValues = dataView.categorical.values[i].values;
            }
        }

        const valuesColumn: DataViewValueColumn = categorical.Values[0];
        const categoryType: valueType = AxisHelper.getCategoryValueType(categorical.Date.source, true);

        const categoricalValues: LineDotChartColumns<any[]> = LineDotChartColumns.getCategoricalValues(dataView);

        const settings: Settings = Settings.parseSettings(
            dataView,
            localizationManager,
            colorHelper,
        );

        if (counterValues && counterValues.length > 0) {
            let fValue: any = counterValues[0];
            settings.isCounterDateTime.isCounterDateTime = fValue.getDate ? true : false;
        }

        let hasHighlights: boolean = !!(categorical.Values.length > 0 && valuesColumn.highlights);

        const dateColumnFormatter = valueFormatter.create({
            format: valueFormatter.getFormatStringByColumn(categorical.Date.source, true) || categorical.Date.source.format,
            cultureSelector: visualHost.locale
        });

        let extentValues: [number, number] = d3.extent(categoricalValues.Values),
            yMinValue: number = extentValues[0],
            yMaxValue: number = extentValues[1],
            dotPoints: LineDotPoint[] = [],
            sumOfValues: number = 0;

        const dateValues: DateValue[] = [],
            isOrdinal: boolean = AxisHelper.isOrdinal(categoryType),
            isDateTime: boolean = AxisHelper.isDateTime(categoryType);

        for (let valueIndex: number = 0, length: number = categoricalValues.Date.length; valueIndex < length; valueIndex++) {
            const value: number = categoricalValues.Values[valueIndex] || 0;
            let dateValue: DateValue = new DateValue(categoricalValues.Date[valueIndex], null);

            if (isDateTime) {
                dateValue.value = categoricalValues.Date[valueIndex].getTime();
            } else if (!isOrdinal) {
                dateValue.value = categoricalValues.Date[valueIndex];
            } else {
                dateValue.value = valueIndex;
            }

            dateValues.push(dateValue);
            sumOfValues += value;

            const selector: ISelectionId = visualHost.createSelectionIdBuilder()
                .withCategory(categorical.Date, valueIndex)
                .createSelectionId();

            dotPoints.push({
                dateValue,
                value,
                dot: (yMaxValue - yMinValue)
                    ? (value - yMinValue) / (yMaxValue - yMinValue)
                    : 0,
                sum: sumOfValues,
                selected: false,
                identity: selector,
                highlight: hasHighlights && !!(valuesColumn.highlights[valueIndex]),
                opacity: settings.dotoptions.percentile / 100,
                counter: counterValues ? counterValues[valueIndex] : null
            });
        }

        // make some space for counter + 25%
        sumOfValues = sumOfValues + (sumOfValues - yMinValue) * LineDotChart.makeSomeSpaceForCounter;

        const columnNames: ColumnNames = {
            category: LineDotChart.getDisplayName(categorical.Date),
            values: LineDotChart.getDisplayName(valuesColumn)
        };

        const dataValueFormatter: IValueFormatter = valueFormatter.create({
            format: valueFormatter.getFormatStringByColumn(valuesColumn.source, true) || "#",
            cultureSelector: visualHost.locale
        });

        return {
            columnNames,
            dotPoints,
            settings,
            dataValueFormatter,
            dateColumnFormatter,
            isOrdinal,
            dateValues,
            yMinValue,
            yMaxValue,
            sumOfValues,
            hasHighlights,
            dateMetadataColumn: categorical.Date.source,
            valuesMetadataColumn: valuesColumn.source
        };
    }