Skip to content

The open alternative to Salesforce, designed for AI.

3.2 KB
Raw Blame
import { NICE_STEP_MULTIPLIERS } from '@/page-layout/widgets/graph/constants/NiceStepMultipliers';
import { NICE_STEP_NORMALIZED_VALUE_THRESHOLDS } from '@/page-layout/widgets/graph/constants/NiceStepNormalizedValueThresholds';

const computeNiceStepInterval = (roughStepInterval: number): number => {
  if (roughStepInterval === 0) {
    return 0;
  }

  const stepMagnitude = Math.pow(
    10,
    Math.floor(Math.log10(Math.abs(roughStepInterval))),
  );
  const normalizedStepValue = roughStepInterval / stepMagnitude;

  if (normalizedStepValue >= NICE_STEP_NORMALIZED_VALUE_THRESHOLDS.LARGE)
    return NICE_STEP_MULTIPLIERS.LARGE * stepMagnitude;
  if (normalizedStepValue >= NICE_STEP_NORMALIZED_VALUE_THRESHOLDS.MEDIUM)
    return NICE_STEP_MULTIPLIERS.MEDIUM * stepMagnitude;
  if (normalizedStepValue >= NICE_STEP_NORMALIZED_VALUE_THRESHOLDS.SMALL)
    return NICE_STEP_MULTIPLIERS.SMALL * stepMagnitude;
  return NICE_STEP_MULTIPLIERS.DEFAULT * stepMagnitude;
};

export const computeValueTickValues = ({
  minimum,
  maximum,
  tickCount,
  preserveDomainBounds = false,
}: {
  minimum: number;
  maximum: number;
  tickCount: number;
  preserveDomainBounds?: boolean;
}): {
  tickValues: number[];
  domain: { min: number; max: number };
} => {
  if (!Number.isFinite(minimum) || !Number.isFinite(maximum)) {
    return { tickValues: [], domain: { min: 0, max: 0 } };
  }

  if (minimum === maximum) {
    return { tickValues: [minimum], domain: { min: minimum, max: minimum } };
  }

  const safeTickCount = Math.max(2, tickCount);
  const roughStepInterval = (maximum - minimum) / (safeTickCount - 1);
  const niceStepInterval = computeNiceStepInterval(roughStepInterval);

  if (niceStepInterval === 0) {
    return {
      tickValues: [minimum, maximum],
      domain: { min: minimum, max: maximum },
    };
  }

  if (preserveDomainBounds) {
    if (minimum > maximum) {
      return {
        tickValues: [minimum],
        domain: { min: minimum, max: minimum },
      };
    }

    const tickValues: number[] = [Number(minimum.toFixed(12))];
    const firstInteriorTick =
      Math.ceil(minimum / niceStepInterval) * niceStepInterval;

    for (
      let tickValue = firstInteriorTick;
      tickValue <= maximum + niceStepInterval / 2;
      tickValue += niceStepInterval
    ) {
      const roundedTickValue = Number(tickValue.toFixed(12));

      if (roundedTickValue > minimum && roundedTickValue < maximum) {
        tickValues.push(roundedTickValue);
      }
    }

    const roundedMaximum = Number(maximum.toFixed(12));

    if (tickValues[tickValues.length - 1] !== roundedMaximum) {
      tickValues.push(roundedMaximum);
    }

    return {
      tickValues,
      domain: { min: minimum, max: maximum },
    };
  }

  const niceMinimum = Math.floor(minimum / niceStepInterval) * niceStepInterval;
  const niceMaximum = Math.ceil(maximum / niceStepInterval) * niceStepInterval;
  const tickValues: number[] = [];

  for (
    let tickValue = niceMinimum;
    tickValue <= niceMaximum + niceStepInterval / 2;
    tickValue += niceStepInterval
  ) {
    tickValues.push(Number(tickValue.toFixed(12)));
  }

  return {
    tickValues,
    domain: { min: niceMinimum, max: niceMaximum },
  };
};