Function scaleCalcAlign

src/coord/axisAlignTicks.ts:44–360

(
    targetAxis: Axis,
    alignToScale: IntervalScale | LogScale
)

 * @see SCALE_EXTENT_CONSTRUCTION for the full processing flow.
 */
export function scaleCalcAlign(
    targetAxis: Axis,
    alignToScale: IntervalScale | LogScale
): void {

    const targetScale = targetAxis.scale as (IntervalScale | LogScale) & Scale;
    const targetAxisModel = targetAxis.model;
    if (__DEV__) {
        assert(targetScale && targetAxisModel
            && (targetScale instanceof IntervalScale || targetScale instanceof LogScale)
            && (alignToScale instanceof IntervalScale || alignToScale instanceof LogScale)
        );
    }
    const targetExtentInfo = adoptScaleRawExtentInfoAndPrepare(
        targetScale, targetAxisModel, targetAxisModel.ecModel, targetAxis, null
    );

    // FIXME:
    //  (1) Axis inverse is not considered yet.
    //  (2) `SCALE_EXTENT_KIND_MAPPING` is not considered yet.

    const isTargetLogScale = isLogScale(targetScale);
    const alignToScaleLinear = isLogScale(alignToScale) ? alignToScale.intervalStub : alignToScale;
    const targetIntervalStub = isTargetLogScale ? targetScale.intervalStub : targetScale;

    const targetLogScaleBase = (targetScale as LogScale).base;
    const alignToTicks = alignToScaleLinear.getTicks();
    const alignToExpNiceTicks = alignToScaleLinear.getTicks({expandToNicedExtent: true});
    const alignToSegCount = alignToTicks.length - 1;

    if (__DEV__) {
        // This is guards for future changes of `Interval#getTicks`.
        assert(!hasBreaks(alignToScale) && !hasBreaks(targetScale));
        assert(alignToSegCount > 0); // Ticks length >= 2 even on a blank scale.
        assert(alignToExpNiceTicks.length === alignToTicks.length);
        assert(alignToTicks[0].value <= alignToTicks[alignToSegCount].value);
        assert(
            alignToExpNiceTicks[0].value <= alignToTicks[0].value
            && alignToTicks[alignToSegCount].value <= alignToExpNiceTicks[alignToSegCount].value
        );
        if (alignToSegCount >= 2) {
            assert(alignToExpNiceTicks[1].value === alignToTicks[1].value);
            assert(alignToExpNiceTicks[alignToSegCount - 1].value === alignToTicks[alignToSegCount - 1].value);
        }
    }

    // The Current strategy: Find a proper interval and an extent for the target scale to derive ticks
    // matching exactly to ticks of `alignTo` scale.

    // Adjust min, max based on the extent of alignTo. When min or max is set in alignTo scale
    let t0: number; // diff ratio on min not-nice segment. 0 <= t0 < 1
    let t1: number; // diff ratio on max not-nice segment. 0 <= t1 < 1
    let alignToNiceSegCount: number; // >= 1
    // Consider ticks of `alignTo`, only these cases below may occur:
    if (alignToSegCount === 1) {
        // `alignToTicks` is like:
        //  |--|
        // In this case, we make the corresponding 2 target ticks "nice".