export function createScale()

in src/axis/axis.ts [805:903]
82 lines of code
41 McCabe index (conditional complexity)

export function createScale(options: CreateAxisOptions): CreateScaleResult {
    let pixelSpan = options.pixelSpan,
        dataDomain = options.dataDomain,
        metaDataColumn = options.metaDataColumn,
        outerPadding = options.outerPadding || 0,
        isScalar = !!options.isScalar,
        isVertical = !!options.isVertical,
        forcedTickCount = options.forcedTickCount,
        categoryThickness = options.categoryThickness,
        shouldClamp = !!options.shouldClamp,
        maxTickCount = options.maxTickCount,
        disableNice = options.disableNice,
        disableNiceOnlyForScale = options.disableNiceOnlyForScale,
        innerPadding = options.innerPadding,
        useRangePoint = options.useRangePoints;

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

    let maxTicks = isVertical ? getRecommendedNumberOfTicksForYAxis(pixelSpan) : getRecommendedNumberOfTicksForXAxis(pixelSpan);
    if (maxTickCount &&
        maxTicks > maxTickCount)
        maxTicks = maxTickCount;

    let scalarDomain = dataDomain ? dataDomain.slice() : null;
    let bestTickCount = maxTicks;
    if (disableNice) {
        bestTickCount = null;
    }
    let scale: ScaleOrdinal<any, any> | ScaleLinear<any, any> | ScalePoint<any> | ScaleBand<any>;
    let usingDefaultDomain = false;

    if (dataDomain == null || (dataDomain.length === 2 && dataDomain[0] == null && dataDomain[1] == null) || (dataDomain.length !== 2 && isScalar)) {
        usingDefaultDomain = true;

        if (dataType.dateTime || !isOrdinal(dataType))
            dataDomain = emptyDomain;
        else // ordinal
            dataDomain = [];

        if (isOrdinal(dataType)) {
            scale = createOrdinalScale(pixelSpan, dataDomain, categoryThickness ? outerPadding / categoryThickness : 0, innerPadding, useRangePoint);
        }
        else {
            scale = createNumericalScale(options.scaleType, pixelSpan, dataDomain, dataType, outerPadding, bestTickCount);
        }
    }
    else {
        if (isScalar && dataDomain.length > 0) {
            if (!disableNice) {
                bestTickCount = forcedTickCount !== undefined
                    ? (maxTicks !== 0 ? forcedTickCount : 0)
                    : getBestNumberOfTicks(dataDomain[0], dataDomain[dataDomain.length - 1], [metaDataColumn], maxTicks, dataType.dateTime);
            }
            let normalizedRange = normalizeLinearDomain({ min: dataDomain[0], max: dataDomain[dataDomain.length - 1] });
            scalarDomain = [normalizedRange.min, normalizedRange.max];
        }

        if (isScalar && dataType.numeric && !dataType.dateTime) {
            if (scalarDomain && scalarDomain.length === 2 && scalarDomain[0] === 0 && scalarDomain[1] === 0 && options.zeroScalarDomain) {
                scalarDomain[0] = options.zeroScalarDomain[0];
                scalarDomain[1] = options.zeroScalarDomain[1];
            }

            let bestTickCountForNumericalScale = bestTickCount;
            if (disableNiceOnlyForScale) {
                bestTickCountForNumericalScale = null;
            }

            scale = createNumericalScale(options.scaleType, pixelSpan, scalarDomain, dataType, outerPadding, bestTickCountForNumericalScale, shouldClamp);
        }
        else if (isScalar && dataType.dateTime) {
            // Use of a linear scale, instead of a D3.time.scale, is intentional since we want
            // to control the formatting of the time values, since d3's implementation isn't
            // in accordance to our design.
            //     scalarDomain: should already be in long-int time (via category.values[0].getTime())
            scale = createLinearScale(pixelSpan, scalarDomain, outerPadding, null, shouldClamp); // DO NOT PASS TICKCOUNT
        }
        else if (dataType.text || dataType.dateTime || dataType.numeric || dataType.bool) {
            scale = createOrdinalScale(pixelSpan, scalarDomain, categoryThickness ? outerPadding / categoryThickness : 0, innerPadding, useRangePoint);
            bestTickCount = maxTicks === 0 ? 0
                : Math.min(
                    scalarDomain.length,
                    (pixelSpan - outerPadding * 2) / MinOrdinalRectThickness);
        }
    }

    // vertical ordinal axis (e.g. categorical bar chart) does not need to reverse
    if (isVertical && isScalar) {
        (<any>scale).range(scale.range().reverse() as any);
    }

    normalizeInfinityInScale(scale as ScaleLinear<any, any>);

    return {
        scale: scale as any,
        bestTickCount: bestTickCount,
        usingDefaultDomain: usingDefaultDomain,
    };
}