export function createAxis()

in src/axis/axis.ts [665:765]
89 lines of code
23 McCabe index (conditional complexity)

export function createAxis(options: CreateAxisOptions): IAxisProperties {
    let pixelSpan = options.pixelSpan,
        dataDomain = options.dataDomain,
        metaDataColumn = options.metaDataColumn,
        formatString = options.formatString,
        outerPadding = options.outerPadding || 0,
        isCategoryAxis = !!options.isCategoryAxis,
        isScalar = !!options.isScalar,
        isVertical = !!options.isVertical,
        useTickIntervalForDisplayUnits = !!options.useTickIntervalForDisplayUnits, // DEPRECATE: same meaning as isScalar?
        getValueFn = options.getValueFn,
        categoryThickness = options.categoryThickness,
        axisDisplayUnits = options.axisDisplayUnits,
        axisPrecision = options.axisPrecision,
        is100Pct = !!options.is100Pct,
        disableNice = options.disableNice;

    let dataType: ValueType = getCategoryValueType(metaDataColumn, isScalar);

    // Create the Scale
    let scaleResult: CreateScaleResult = createScale(options);
    let scale = scaleResult.scale;
    let bestTickCount = scaleResult.bestTickCount;
    let scaleDomain = scale.domain();
    let isLogScaleAllowed = isLogScalePossible(dataDomain, dataType);

    // fix categoryThickness if scalar and the domain was adjusted when making the scale "nice"
    if (categoryThickness && isScalar && dataDomain && dataDomain.length === 2) {
        let oldSpan = dataDomain[1] - dataDomain[0];
        let newSpan = scaleDomain[1] - scaleDomain[0];
        if (oldSpan > 0 && newSpan > 0) {
            categoryThickness = categoryThickness * oldSpan / newSpan;
        }
    }

    // Prepare Tick Values for formatting
    let tickValues: any[];
    if (isScalar && bestTickCount === 1 && !arrayIsEmpty(dataDomain)) {
        tickValues = [dataDomain[0]];
    }
    else {
        let minTickInterval = isScalar ? getMinTickValueInterval(formatString, dataType, is100Pct) : undefined;
        tickValues = getRecommendedTickValues(bestTickCount, scale, dataType, isScalar, minTickInterval);
    }

    if (options.scaleType && options.scaleType === axisScale.log && isLogScaleAllowed) {
        tickValues = tickValues.filter((d) => { return powerOfTen(d); });
    }

    let formatter = createFormatter(
        scaleDomain,
        dataDomain,
        dataType,
        isScalar,
        formatString,
        bestTickCount,
        tickValues,
        getValueFn,
        useTickIntervalForDisplayUnits,
        axisDisplayUnits,
        axisPrecision);

    // sets default orientation only, cartesianChart will fix y2 for comboChart
    // tickSize(pixelSpan) is used to create gridLines
    let axisFunction = isVertical ? axisLeft : axisBottom;
    let axis = axisFunction(scale)
        .tickSize(6)
        .ticks(bestTickCount)
        .tickValues(tickValues);

    let formattedTickValues = [];
    if (metaDataColumn)
        formattedTickValues = formatAxisTickValues(axis, tickValues, formatter, dataType, getValueFn);

    let xLabelMaxWidth;
    // Use category layout of labels if specified, otherwise use scalar layout of labels
    if (!isScalar && categoryThickness) {
        xLabelMaxWidth = Math.max(1, categoryThickness - TickLabelPadding * 2);
    }
    else {
        // When there are 0 or 1 ticks, then xLabelMaxWidth = pixelSpan
        xLabelMaxWidth = tickValues.length > 1 ? getScalarLabelMaxWidth(scale, tickValues) : pixelSpan;
        xLabelMaxWidth = xLabelMaxWidth - ScalarTickLabelPadding * 2;
    }

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