private getXPoints()

in src/visual.ts [1384:1446]
58 lines of code
15 McCabe index (conditional complexity)

    private getXPoints(): number[] {
        const { start, end } = this.data.settings.xAxis,
            { minX, maxX } = this.data.borderValues,
            { dataPoints } = this.data,
            interval: number = this.data.dataPoints[0].x1 - this.data.dataPoints[0].x0;
        let xPoints: number[],
            tmpStart: number,
            tmpEnd: number,
            tmpArr: number[],
            closerLimit: number;

        xPoints = dataPoints.reduce(
            (previousValue: number[], currentValue: HistogramDataPoint, index: number) =>
                previousValue.concat((index === 0)
                ? currentValue.range
                : currentValue.range.slice(1)),
            []
        );

        // It is necessary to find out interval to calculate all necessary points before and after offset (if start and end for X axis was changed by user)
        if ((maxX !== end || minX !== start) && xPoints.length > 1) {

            // The interval must be greater than zero to avoid infinity loops
            if (Visual.isIntervalValid(interval)) {
                // If start point is greater than min border, it is necessary to remove non-using data points
                if (start > minX) {
                    closerLimit = this.findBorderMinCloserToXAxisStart(minX, start, interval);
                    xPoints = xPoints.filter(dpv => this.formatXLabelsForFiltering(dpv) >= closerLimit);
                    this.data.xCorrectedMin = xPoints && xPoints.length > 0 ? xPoints[0] : null;
                }
                else {
                    // Add points before
                    tmpArr = [];
                    tmpStart = minX;
                    while (start < tmpStart) {
                        tmpStart = tmpStart - interval;
                        tmpArr.push(tmpStart);
                        this.data.xCorrectedMin = tmpStart;
                    }
                    tmpArr.reverse();
                    xPoints = tmpArr.concat(xPoints);
                }

                // If end point is lesser than max border, it is necessary to remove non-using data points
                if (end < maxX) {
                    closerLimit = this.findBorderMaxCloserToXAxisEnd(maxX, end, interval);
                    xPoints = xPoints.filter(dpv => this.formatXLabelsForFiltering(dpv) <= closerLimit);
                    this.data.xCorrectedMax = xPoints && xPoints.length > 0 ? xPoints[xPoints.length - 1] : null;
                }
                else {
                    // Add points after
                    tmpEnd = maxX;
                    while (end > tmpEnd) {
                        tmpEnd = tmpEnd + interval;
                        xPoints.push(tmpEnd);
                        this.data.xCorrectedMax = tmpEnd;
                    }
                }
            }
        }

        return xPoints;
    }