export function createScale()

in src/axisHelper.ts [524:623]
88 lines of code
29 McCabe index (conditional complexity)

export function createScale(options: CreateAxisOptionsExtended): CreateScaleResult {
    let pixelSpan: number = options.pixelSpan,
        dataDomain: number[] = options.dataDomain,
        metaDataColumn: DataViewMetadataColumn = options.metaDataColumn,
        outerPadding: number = options.outerPadding || DefaultOuterPadding,
        isScalar: boolean = !!options.isScalar,
        isVertical: boolean = !!options.isVertical,
        forcedTickCount: number = options.forcedTickCount,
        categoryThickness: number = options.categoryThickness,
        shouldClamp: boolean = !!options.shouldClamp,
        maxTickCount: number = options.maxTickCount,
        innerPaddingRatio: number = options.innerPaddingRatio || InnerPaddingRatio,
        minOrdinalRectThickness: number = options.minOrdinalRectThickness || MinOrdinalRectThickness;

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

    let maxTicks: number = getMaxTicks(isVertical, pixelSpan, maxTickCount);

    let scalarDomain: number[] = dataDomain ? dataDomain.slice() : null;

    let bestTickCount: number = maxTicks;
    let scale: LinearScale<any, any> | OrdinalScale<any, any> | ScaleBand<any>;
    let usingDefaultDomain: boolean = false;

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

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

            scalarDomain = getScalarDomain(dataDomain, scalarDomain);
        }

        if (isScalar && dataType.numeric && !dataType.dateTime) {
            // Note: Don't pass bestTickCount to createNumericalScale, because it overrides boundaries of the domain.
            scale = createNumericalScale(
                options.scaleType,
                pixelSpan,
                scalarDomain,
                dataType,
                outerPadding,
                null,
                shouldClamp);
            bestTickCount = maxTicks === 0 ? 0 : Math.floor((pixelSpan - outerPadding * 2) / minOrdinalRectThickness);
        }
        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,
                innerPaddingRatio,
                categoryThickness ? outerPadding / categoryThickness : 0);

            bestTickCount = maxTicks === 0 ? 0
                : Math.min(
                    scalarDomain.length,
                    (pixelSpan - outerPadding * 2) / minOrdinalRectThickness);
        }
    }

    normalizeInfinityInScale(<LinearScale<any, any>>scale);

    return {
        scale: <LinearScale<any, any>>scale,
        bestTickCount: bestTickCount,
        usingDefaultDomain: usingDefaultDomain,
    };
}