private createAxis()

in src/visualStrategy/baseVisualStrategy.ts [279:372]
82 lines of code
10 McCabe index (conditional complexity)

    private createAxis(options: CreateAxisOptions): IAxisProperties {
        const pixelSpan: number = options.pixelSpan,
            dataDomain: number[] = options.dataDomain,
            metaDataColumn: DataViewMetadataColumn = options.metaDataColumn,
            outerPadding: number = options.outerPadding || 0,
            isCategoryAxis: boolean = !!options.isCategoryAxis,
            isScalar: boolean = !!options.isScalar,
            isVertical: boolean = !!options.isVertical,
            useTickIntervalForDisplayUnits: boolean = !!options.useTickIntervalForDisplayUnits,
            getValueFn: (index: number, type: ValueType) => any = options.getValueFn,
            categoryThickness: number = options.categoryThickness,
            formatString: string = valueFormatter.getFormatStringByColumn(metaDataColumn),
            dataType: ValueType = AxisHelper.getCategoryValueType(metaDataColumn, isScalar),
            isLogScaleAllowed: boolean = AxisHelper.isLogScalePossible(dataDomain, dataType),
            scale: d3.ScaleLinear<number, number> = d3scale.scaleLinear(),
            scaleDomain: number[] = [0, 1],
            bestTickCount: number = dataDomain.length || 1,
            borderWidth: number = columnChart.BaseColumnChart.getBorderWidth(options.borderSettings);

        let chartWidth: number = pixelSpan - borderWidth * (bestTickCount - 1);

        if (chartWidth < MekkoChart.MinOrdinalRectThickness) {
            chartWidth = MekkoChart.MinOrdinalRectThickness;
        }

        scale
            .domain(scaleDomain)
            .range([0, chartWidth]);

        const formatter: IValueFormatter = BaseVisualStrategy.createFormatter(
            scaleDomain,
            dataDomain,
            dataType,
            isScalar,
            formatString,
            bestTickCount,
            dataDomain,
            getValueFn,
            useTickIntervalForDisplayUnits);

        let axisFn = isVertical ? axisLeft : axisBottom;
        const axis: d3.Axis<any> = axisFn(scale)
            .tickSize(6)
            .ticks(bestTickCount)
            .tickValues(dataDomain);

        let formattedTickValues: any[] = [];

        if (metaDataColumn) {
            formattedTickValues = BaseVisualStrategy.formatAxisTickValues(
                axis,
                dataDomain,
                formatter,
                dataType,
                isScalar,
                getValueFn);
        }

        let xLabelMaxWidth: any;

        if (!isScalar && categoryThickness) {
            xLabelMaxWidth = Math.max(
                1,
                categoryThickness - MekkoChart.TickLabelPadding * BaseVisualStrategy.TickLabelPaddingFactor);
        }
        else {
            const labelAreaCount: number = dataDomain.length > 1
                ? dataDomain.length + 1
                : dataDomain.length;

            xLabelMaxWidth = labelAreaCount > 1
                ? pixelSpan / labelAreaCount
                : pixelSpan;

            xLabelMaxWidth = Math.max(
                1,
                xLabelMaxWidth - MekkoChart.TickLabelPadding * BaseVisualStrategy.TickLabelPaddingFactor);
        }

        return {
            scale,
            axis,
            formatter,
            isCategoryAxis,
            xLabelMaxWidth,
            categoryThickness,
            outerPadding,
            isLogScaleAllowed,
            values: formattedTickValues,
            axisType: dataType,
            axisLabel: null,
            usingDefaultDomain: false
        };
    }