direction: getDirection()

in packages/charts/src/chart_types/xy_chart/state/selectors/visible_ticks.ts [97:184]
85 lines of code
21 McCabe index (conditional complexity)

      direction: getDirection(label),
      multilayerTimeAxis,
    };
  });
}

function getVisibleTicks(
  axisSpec: AxisSpec,
  labelBox: TickLabelBounds,
  totalBarsInCluster: number,
  labelFormatter: AxisLabelFormatter,
  rotationOffset: number,
  scale: ScaleBand | ScaleContinuous,
  enableHistogramMode: boolean,
  layer: number | undefined,
  detailedLayer: number,
  ticks: (number | string)[],
  multilayerTimeAxis: boolean = false,
  showGrid = true,
): AxisTick[] {
  const isSingleValueScale = scale.domain[0] === scale.domain[1];
  const makeRaster = enableHistogramMode && scale.bandwidth > 0 && !multilayerTimeAxis;
  const ultimateTick = ticks.at(-1);
  const penultimateTick = ticks.at(-2);
  if (makeRaster && !isSingleValueScale && typeof penultimateTick === 'number' && typeof ultimateTick === 'number') {
    const computedTickDistance = ultimateTick - penultimateTick;
    const numTicks = scale.minInterval / (computedTickDistance || scale.minInterval); // avoid infinite loop
    for (let i = 1; i <= numTicks; i++) ticks.push(i * computedTickDistance + ultimateTick);
  }
  const shift = totalBarsInCluster > 0 ? totalBarsInCluster : 1;
  const band = scale.bandwidth / (1 - scale.barsPadding);
  const halfPadding = (band - scale.bandwidth) / 2;
  const offset =
    (enableHistogramMode ? -halfPadding : (scale.bandwidth * shift) / 2) + (scale.isSingleValue() ? 0 : rotationOffset);

  const firstTickValue = ticks[0];
  const allTicks: AxisTick[] =
    makeRaster && isSingleValueScale && typeof firstTickValue === 'number'
      ? [
          {
            value: firstTickValue,
            domainClampedValue: firstTickValue,
            label: labelFormatter(firstTickValue),
            position: (scale.scale(firstTickValue) || 0) + offset,
            domainClampedPosition: (scale.scale(firstTickValue) || 0) + offset,
            layer: undefined, // no multiple layers with `singleValueScale`s
            detailedLayer: 0,
            direction: 'rtl',
            showGrid,
            multilayerTimeAxis,
          },
          {
            value: firstTickValue + scale.minInterval,
            domainClampedValue: firstTickValue + scale.minInterval,
            label: labelFormatter(firstTickValue + scale.minInterval),
            position: scale.bandwidth + halfPadding * 2,
            domainClampedPosition: scale.bandwidth + halfPadding * 2,
            layer: undefined, // no multiple layers with `singleValueScale`s
            detailedLayer: 0,
            direction: 'rtl',
            showGrid,
            multilayerTimeAxis,
          },
        ]
      : generateTicks(
          axisSpec,
          scale,
          ticks,
          offset,
          labelFormatter,
          layer,
          detailedLayer,
          showGrid,
          multilayerTimeAxis,
        );

  const { showOverlappingTicks, showOverlappingLabels, position } = axisSpec;
  const requiredSpace = isVerticalAxis(position) ? labelBox.maxLabelBboxHeight / 2 : labelBox.maxLabelBboxWidth / 2;
  const bypassOverlapCheck = showOverlappingLabels || multilayerTimeAxis;
  return bypassOverlapCheck
    ? allTicks
    : allTicks
        .slice()
        .sort((a: AxisTick, b: AxisTick) => a.position - b.position)
        .reduce(
          (prev, tick) => {
            const tickLabelFits = tick.position >= prev.occupiedSpace + requiredSpace;
            if (tickLabelFits || showOverlappingTicks) {