solid-recharts 0.1.0

package/src/util/scale/CartesianScaleHelper.ts

@@ -0,0 +1,72 @@
+// Ported from recharts 3.8.1 src/util/scale/CartesianScaleHelper.ts (commit 7a23854).
+import { BandPosition, RechartsScale } from "./RechartsScale";
+import { CategoricalDomainItem, Coordinate, NullableCoordinate } from "../types";
+
+export interface CartesianScaleHelper<
+  XDomain extends CategoricalDomainItem = CategoricalDomainItem,
+  YDomain extends CategoricalDomainItem = CategoricalDomainItem,
+> {
+  map(value: { x: XDomain; y: YDomain }, { position }: { position: BandPosition }): Coordinate;
+
+  mapWithFallback(
+    value: { x?: XDomain | null | undefined; y?: YDomain | null | undefined },
+    { position, fallback }: { position?: BandPosition; fallback: "rangeMin" | "rangeMax" },
+  ): Coordinate;
+
+  isInRange({ x, y }: Partial<NullableCoordinate>): boolean;
+}
+
+/**
+ * Groups X and Y scale functions together and provides helper methods.
+ */
+export class CartesianScaleHelperImpl<
+  XDomain extends CategoricalDomainItem = CategoricalDomainItem,
+  YDomain extends CategoricalDomainItem = CategoricalDomainItem,
+> implements CartesianScaleHelper<XDomain, YDomain> {
+  private xAxisScale: RechartsScale<XDomain>;
+
+  private yAxisScale: RechartsScale<YDomain>;
+
+  constructor({ x, y }: { x: RechartsScale<XDomain>; y: RechartsScale<YDomain> }) {
+    this.xAxisScale = x;
+    this.yAxisScale = y;
+  }
+
+  map(value: { x: XDomain; y: YDomain }, { position }: { position: BandPosition }): Coordinate {
+    return {
+      x: this.xAxisScale.map(value.x, { position }) ?? 0,
+      y: this.yAxisScale.map(value.y, { position }) ?? 0,
+    };
+  }
+
+  mapWithFallback(
+    value: { x?: XDomain | null | undefined; y?: YDomain | null | undefined },
+    { position, fallback }: { position?: BandPosition; fallback: "rangeMin" | "rangeMax" },
+  ): Coordinate {
+    let fallbackY: number, fallbackX: number;
+    if (fallback === "rangeMin") {
+      fallbackY = this.yAxisScale.rangeMin();
+    } else if (fallback === "rangeMax") {
+      fallbackY = this.yAxisScale.rangeMax();
+    } else {
+      fallbackY = 0;
+    }
+    if (fallback === "rangeMin") {
+      fallbackX = this.xAxisScale.rangeMin();
+    } else if (fallback === "rangeMax") {
+      fallbackX = this.xAxisScale.rangeMax();
+    } else {
+      fallbackX = 0;
+    }
+    return {
+      x: this.xAxisScale.map(value.x, { position }) ?? fallbackX,
+      y: this.yAxisScale.map(value.y, { position }) ?? fallbackY,
+    };
+  }
+
+  isInRange({ x, y }: Partial<NullableCoordinate>): boolean {
+    const xInRange = x == null || this.xAxisScale.isInRange(x);
+    const yInRange = y == null || this.yAxisScale.isInRange(y);
+    return xInRange && yInRange;
+  }
+}

package/src/util/scale/CustomScaleDefinition.ts

@@ -0,0 +1,82 @@
+// Ported from recharts 3.8.1 src/util/scale/CustomScaleDefinition.ts (commit 7a23854).
+import { CategoricalDomainItem } from "../types";
+
+/**
+ * A subset of d3-scale. This is the external representation;
+ * This is the type that we expect from `axis.scale` props, if users want to provide custom scales.
+ *
+ * The actual d3 scales have many more methods, but we don't need them all.
+ * Specifically we want to avoid all the setters
+ * - immutable API is preferred in Recharts and mutating state will lead to hard-to-debug issues.
+ *
+ * @see {@link ScaleType} and {@link RechartsScaleType} for string shortcuts that you can use instead of this interface.
+ */
+export interface CustomScaleDefinition<
+  Domain extends CategoricalDomainItem = CategoricalDomainItem,
+> {
+  /**
+   * Returns the scale's current domain.
+   * The domain could be:
+   * - in categorical scales: an array of strings or categories
+   * - in continuous scales: tuple of two numbers: [min, max]
+   */
+  domain(): ReadonlyArray<Domain>;
+
+  /**
+   * Sets the domain of the scale.
+   */
+  domain(newDomain: ReadonlyArray<Domain>): this;
+
+  /**
+   * Returns the scale's current range.
+   */
+  range(): ReadonlyArray<number>;
+
+  /**
+   * Sets the range of the scale.
+   */
+  range(newRange: ReadonlyArray<number>): this;
+
+  /**
+   * Returns an exact copy of this scale. Changes to this scale will not affect the returned scale, and vice versa.
+   * We use this method in Recharts to ensure immutability - changes to the scale outside should not affect the internal state,
+   * as they won't trigger re-renders in React.
+   */
+  copy(): CustomScaleDefinition<Domain>;
+
+  /**
+   * Returns width of each band.
+   * Most scales are not banded, so this method is optional.
+   * Banded scales (like scaleBand from d3-scale) will implement this method.
+   */
+  bandwidth?: () => number;
+  /**
+   * Quantitative (continuous) scales provide a ticks method that returns representative values from the scale's domain.
+   * Ordinal and band scales do not have this method.
+   *
+   * An optional count argument requests more or fewer ticks.
+   * The number of ticks returned, however, is not necessarily equal to the requested count.
+   *
+   * @see {@link https://d3js.org/d3-scale/linear#linear_ticks}
+   * @see {@link https://observablehq.com/@d3/scale-ticks}
+   *
+   * @param count number of ticks
+   */
+  ticks?: (count: number | undefined) => ReadonlyArray<number>;
+
+  /**
+   * Given an arbitrary input, returns the corresponding point derived from the output range if the input is in the scale's domain.
+   * If the input is not included in the domain, returns undefined.
+   *
+   * @param input
+   */
+  (input: Domain): number | undefined;
+
+  /**
+   * Given a value from the range, returns the corresponding value from the domain.
+   *
+   * This method is optional, as not all scales provide an inverse mapping.
+   * Linear and time scales typically do, while band and ordinal scales may not.
+   */
+  invert?(value: number): Domain | undefined;
+}

package/src/util/scale/RechartsScale.ts

@@ -0,0 +1,131 @@
+// Ported from recharts 3.8.1 src/util/scale/RechartsScale.ts (commit 7a23854).
+import { CustomScaleDefinition } from "./CustomScaleDefinition";
+import { CategoricalDomainItem } from "../types";
+
+/**
+ * This is internal representation of scale used in Recharts.
+ * Users will provide CustomScaleDefinition or a string, which we will parse into RechartsScale.
+ * Most importantly, RechartsScale is fully immutable - there are no setters that mutate the scale in place.
+ * This is important for React integration - if the scale changes, we want to trigger re-renders.
+ * Mutating the scale in place would not trigger re-renders, leading to stale UI.
+ */
+export interface RechartsScale<Domain extends CategoricalDomainItem = CategoricalDomainItem> {
+  /**
+   * Returns the scale's current domain.
+   * The domain could be:
+   * - in categorical scales: an array of strings or categories
+   * - in continuous scales: tuple of two numbers: [min, max]
+   */
+  domain(): ReadonlyArray<Domain>;
+
+  /**
+   * Returns the scale's current range.
+   *
+   * This should be a readonly tuple of two numbers: [min, max]
+   * and so a better type would be `readonly [number, number]` but again - breaking changes,
+   * so let's keep that for 4.0.
+   */
+  range(): ReadonlyArray<number>;
+
+  /**
+   * Returns the minimum value from the range.
+   */
+  rangeMin(): number;
+
+  /**
+   * Returns the maximum value from the range.
+   */
+  rangeMax(): number;
+
+  /**
+   * Returns true if the given value is within the scale's range.
+   * @param value
+   */
+  isInRange(value: number): boolean;
+
+  /**
+   * Returns width of each band.
+   * Most scales are not banded, so this method is optional.
+   * Banded scales (like scaleBand from d3-scale) will implement this method.
+   */
+  bandwidth?: () => number;
+  /**
+   * Quantitative (continuous) scales provide a ticks method that returns representative values from the scale's domain.
+   * Ordinal and band scales do not have this method.
+   *
+   * An optional count argument requests more or fewer ticks.
+   * The number of ticks returned, however, is not necessarily equal to the requested count.
+   *
+   * @see {@link https://d3js.org/d3-scale/linear#linear_ticks}
+   * @see {@link https://observablehq.com/@d3/scale-ticks}
+   *
+   * @param count number of ticks
+   */
+  ticks?: (count: number | undefined) => ReadonlyArray<number>;
+
+  /**
+   * Given an arbitrary input, returns the corresponding point derived from the output range if the input is in the scale's domain.
+   * If the input is not included in the domain, returns undefined.
+   */
+  map(input: unknown, options?: { position?: BandPosition }): number | undefined;
+}
+
+/**
+ * Position within a band for banded scales.
+ * In scales that are not banded, this parameter is ignored.
+ *
+ * @inline
+ */
+export type BandPosition = "start" | "middle" | "end";
+
+export function rechartsScaleFactory<Domain extends CategoricalDomainItem = CategoricalDomainItem>(
+  d3Scale: CustomScaleDefinition<Domain>,
+): RechartsScale<Domain>;
+export function rechartsScaleFactory<Domain extends CategoricalDomainItem = CategoricalDomainItem>(
+  d3Scale: CustomScaleDefinition<Domain> | undefined,
+): RechartsScale<Domain> | undefined;
+export function rechartsScaleFactory<Domain extends CategoricalDomainItem = CategoricalDomainItem>(
+  d3Scale: CustomScaleDefinition<Domain> | undefined,
+): RechartsScale<Domain> | undefined {
+  if (d3Scale == null) {
+    return undefined;
+  }
+  const ticksFn = d3Scale.ticks;
+  const bandwidthFn = d3Scale.bandwidth;
+  const d3Range: ReadonlyArray<number> = d3Scale.range();
+  const range: [number, number] = [Math.min(...d3Range), Math.max(...d3Range)];
+  return {
+    domain: () => d3Scale.domain(),
+    range: () => range,
+    rangeMin: () => range[0],
+    rangeMax: () => range[1],
+    isInRange(value: number): boolean {
+      const first = range[0];
+      const last = range[1];
+      return first <= last ? value >= first && value <= last : value >= last && value <= first;
+    },
+    bandwidth: bandwidthFn ? () => bandwidthFn.call(d3Scale) : undefined,
+    ticks: ticksFn ? (count: number | undefined) => ticksFn.call(d3Scale, count) : undefined,
+    map: (input: Domain, options?: { position?: BandPosition }) => {
+      let baseValue = d3Scale(input);
+      if (baseValue == null) {
+        return undefined;
+      }
+      if (d3Scale.bandwidth && options?.position) {
+        const bandWidth = d3Scale.bandwidth();
+        switch (options.position) {
+          case "middle":
+            baseValue += bandWidth / 2;
+            break;
+          case "end":
+            baseValue += bandWidth;
+            break;
+          default:
+            // 'start' requires no adjustment
+            break;
+        }
+      }
+      return baseValue;
+    },
+  };
+}

package/src/util/scale/createCategoricalInverse.ts

@@ -0,0 +1,83 @@
+// Ported from recharts 3.8.1 src/util/scale/createCategoricalInverse.ts (commit 7a23854).
+//
+// Solid/type deviations from reference (no behavior change):
+//   - `bisect` reads indices into `?? 0` locals instead of non-null `!` (our
+//     tsconfig enables noUncheckedIndexedAccess; the `?? 0` never fires for the
+//     in-bounds accesses the algorithm makes).
+//   - `allDataPointsOnAxis` is typed `ReadonlyArray<CategoricalDomainItem>` (the
+//     scale's actual input type) rather than `unknown[]`, which lets `scale(d)`
+//     typecheck and drops the reference's `@ts-expect-error`.
+import { InverseScaleFunction } from "../../hooks";
+import { CategoricalDomainItem } from "../types";
+import { CustomScaleDefinition } from "./CustomScaleDefinition";
+
+/**
+ * Binary search to find the index where x would fit in array a.
+ * Works for arrays that are sorted both ascending and descending.
+ *
+ * Unlike d3.bisect, this implementation handles both ascending and descending arrays.
+ *
+ * @param haystack Sorted array of numbers
+ * @param needle Number to find the insertion index for
+ * @returns Index where x would fit in array a
+ */
+export function bisect(haystack: ReadonlyArray<number>, needle: number): number {
+  let lo = 0;
+  let hi = haystack.length;
+  const first = haystack[0] ?? 0;
+  const last = haystack[haystack.length - 1] ?? 0;
+  const ascending = first < last;
+
+  while (lo < hi) {
+    const mid = Math.floor((lo + hi) / 2);
+    const midVal = haystack[mid] ?? 0;
+    if (ascending ? midVal < needle : midVal > needle) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  return lo;
+}
+
+/**
+ * Computes an inverse scale function for categorical/ordinal scales.
+ * Uses bisect to find the closest domain value for a given pixel coordinate.
+ */
+export function createCategoricalInverse(
+  scale: CustomScaleDefinition | undefined,
+  allDataPointsOnAxis?: ReadonlyArray<CategoricalDomainItem>,
+): InverseScaleFunction | undefined {
+  if (!scale) {
+    return undefined;
+  }
+  const domain = allDataPointsOnAxis ?? scale.domain();
+  // Build an array of pixel positions for each domain value.
+  const pixelPositions: number[] = domain.map((d) => scale(d) ?? 0);
+  const range = scale.range();
+
+  if (domain.length === 0 || range.length < 2) {
+    return undefined;
+  }
+
+  return (pixelValue: number): unknown => {
+    // Find the closest domain value using bisect
+    const index = bisect(pixelPositions, pixelValue);
+
+    // Clamp to valid range
+    if (index <= 0) {
+      return domain[0];
+    }
+    if (index >= domain.length) {
+      return domain[domain.length - 1];
+    }
+
+    // Check which neighbor is closer
+    const leftPixel = pixelPositions[index - 1] ?? 0;
+    const rightPixel = pixelPositions[index] ?? 0;
+    if (Math.abs(pixelValue - leftPixel) <= Math.abs(pixelValue - rightPixel)) {
+      return domain[index - 1];
+    }
+    return domain[index];
+  };
+}

package/src/util/scale/getNiceTickValues.ts

@@ -0,0 +1,334 @@
+// Ported from recharts 3.8.1 src/util/scale/getNiceTickValues.ts (commit 7a23854).
+// Pure math — no framework surface — so behavior is byte-identical to recharts.
+/**
+ * @fileOverview calculate tick values of scale
+ * @author xile611, arcthur
+ * @date 2015-09-17
+ */
+import Decimal from "./util/DecimalLite";
+import { getDigitCount, rangeStep } from "./util/arithmetic";
+import { NumberDomain } from "../types";
+import { NiceTicksAlgorithm } from "../../state/cartesianAxisSlice";
+
+/**
+ * Calculate a interval of a minimum value and a maximum value
+ *
+ * @param  {Number} min       The minimum value
+ * @param  {Number} max       The maximum value
+ * @return {Array} An interval
+ */
+export const getValidInterval = ([min, max]: [number, number]): [number, number] => {
+  let [validMin, validMax] = [min, max];
+
+  // exchange
+  if (min > max) {
+    [validMin, validMax] = [max, min];
+  }
+
+  return [validMin, validMax];
+};
+
+/**
+ * Calculate the step which is easy to understand between ticks, like 10, 20, 25
+ *
+ * @param  roughStep        The rough step calculated by dividing the difference by the tickCount
+ * @param  allowDecimals    Allow the ticks to be decimals or not
+ * @param  correctionFactor A correction factor
+ * @return The step which is easy to understand between two ticks
+ */
+export const getAdaptiveStep = (
+  roughStep: Decimal,
+  allowDecimals: boolean,
+  correctionFactor: number,
+) => {
+  if (roughStep.lte(0)) {
+    return new Decimal(0);
+  }
+
+  const digitCount = getDigitCount(roughStep.toNumber());
+  // The ratio between the rough step and the smallest number which has a bigger
+  // order of magnitudes than the rough step
+  const digitCountValue = new Decimal(10).pow(digitCount);
+  const stepRatio = roughStep.div(digitCountValue);
+  // When an integer and a float multiplied, the accuracy of result may be wrong
+  const stepRatioScale = digitCount !== 1 ? 0.05 : 0.1;
+  const amendStepRatio = new Decimal(Math.ceil(stepRatio.div(stepRatioScale).toNumber()))
+    .add(correctionFactor)
+    .mul(stepRatioScale);
+
+  const formatStep = amendStepRatio.mul(digitCountValue);
+
+  return allowDecimals
+    ? new Decimal(formatStep.toNumber())
+    : new Decimal(Math.ceil(formatStep.toNumber()));
+};
+
+type StepFunction = (
+  roughStep: Decimal,
+  allowDecimals: boolean,
+  correctionFactor: number,
+) => Decimal;
+
+/**
+ * The snap125 step algorithm snaps to nice numbers (1, 2, 2.5, 5) at each
+ * order of magnitude, producing human-friendly tick intervals like
+ * 0, 5, 10, 15, 20 instead of 0, 4, 8, 12, 16.
+ *
+ * This is opt-in and can be enabled via the `niceTicks` prop on axis components.
+ *
+ * @param  roughStep        The rough step calculated by dividing the difference by the tickCount
+ * @param  allowDecimals    Allow the ticks to be decimals or not
+ * @param  correctionFactor A correction factor
+ * @return The step which is easy to understand between two ticks
+ */
+export const getSnap125Step: StepFunction = (
+  roughStep: Decimal,
+  allowDecimals: boolean,
+  correctionFactor: number,
+) => {
+  if (roughStep.lte(0)) {
+    return new Decimal(0);
+  }
+
+  const NICE_STEPS = [1, 2, 2.5, 5];
+
+  const roughNum = roughStep.toNumber();
+  const exponent = Math.floor(new Decimal(roughNum).abs().log(10).toNumber());
+  let magnitude = new Decimal(10).pow(exponent);
+
+  // normalized is in the range [1, 10)
+  const normalized = roughStep.div(magnitude).toNumber();
+
+  // Find the smallest nice step >= normalized (ceiling)
+  let niceIdx = NICE_STEPS.findIndex((s) => s >= normalized - 1e-10);
+  if (niceIdx === -1) {
+    // normalized > 5 (e.g. 7.3), move to next order of magnitude
+    magnitude = magnitude.mul(10);
+    niceIdx = 0;
+  }
+
+  // Apply correction factor by stepping through the nice number sequence
+  niceIdx += correctionFactor;
+  if (niceIdx >= NICE_STEPS.length) {
+    const extraMag = Math.floor(niceIdx / NICE_STEPS.length);
+    niceIdx %= NICE_STEPS.length;
+    magnitude = magnitude.mul(new Decimal(10).pow(extraMag));
+  }
+
+  const niceStep = NICE_STEPS[niceIdx] ?? 1;
+  const formatStep = new Decimal(niceStep).mul(magnitude);
+
+  return allowDecimals ? formatStep : new Decimal(Math.ceil(formatStep.toNumber()));
+};
+
+/**
+ * calculate the ticks when the minimum value equals to the maximum value
+ *
+ * @param  value         The minimum value which is also the maximum value
+ * @param  tickCount     The count of ticks
+ * @param  allowDecimals Allow the ticks to be decimals or not
+ * @return array of ticks
+ */
+export const getTickOfSingleValue = (
+  value: number,
+  tickCount: number,
+  allowDecimals: boolean,
+): Array<number> => {
+  let step: Decimal = new Decimal(1);
+  // calculate the middle value of ticks
+  let middle = new Decimal(value);
+
+  if (!middle.isint() && allowDecimals) {
+    const absVal = Math.abs(value);
+
+    if (absVal < 1) {
+      // The step should be a float number when the difference is smaller than 1
+      step = new Decimal(10).pow(getDigitCount(value) - 1);
+
+      middle = new Decimal(Math.floor(middle.div(step).toNumber())).mul(step);
+    } else if (absVal > 1) {
+      // Return the maximum integer which is smaller than 'value' when 'value' is greater than 1
+      middle = new Decimal(Math.floor(value));
+    }
+  } else if (value === 0) {
+    middle = new Decimal(Math.floor((tickCount - 1) / 2));
+  } else if (!allowDecimals) {
+    middle = new Decimal(Math.floor(value));
+  }
+
+  const middleIndex = Math.floor((tickCount - 1) / 2);
+  const ticks: Array<number> = [];
+
+  for (let i = 0; i < tickCount; i++) {
+    ticks.push(middle.add(new Decimal(i - middleIndex).mul(step)).toNumber());
+  }
+
+  return ticks;
+};
+
+/**
+ * Calculate the step
+ *
+ * @param  min              The minimum value of an interval
+ * @param  max              The maximum value of an interval
+ * @param  tickCount        The count of ticks
+ * @param  allowDecimals    Allow the ticks to be decimals or not
+ * @param  correctionFactor A correction factor
+ * @return The step, minimum value of ticks, maximum value of ticks
+ */
+export const calculateStep = (
+  min: number,
+  max: number,
+  tickCount: number,
+  allowDecimals: boolean,
+  correctionFactor: number = 0,
+  stepFn: StepFunction = getAdaptiveStep,
+): {
+  step: Decimal;
+  tickMin: Decimal;
+  tickMax: Decimal;
+} => {
+  // dirty hack (for recharts' test)
+  if (!Number.isFinite((max - min) / (tickCount - 1))) {
+    return {
+      step: new Decimal(0),
+      tickMin: new Decimal(0),
+      tickMax: new Decimal(0),
+    };
+  }
+
+  // The step which is easy to understand between two ticks
+  const step = stepFn(
+    new Decimal(max).sub(min).div(tickCount - 1),
+    allowDecimals,
+    correctionFactor,
+  );
+
+  // A medial value of ticks
+  let middle;
+
+  // When 0 is inside the interval, 0 should be a tick
+  if (min <= 0 && max >= 0) {
+    middle = new Decimal(0);
+  } else {
+    // calculate the middle value
+    middle = new Decimal(min).add(max).div(2);
+    // minus modulo value
+    middle = middle.sub(new Decimal(middle).mod(step));
+  }
+
+  let belowCount = Math.ceil(middle.sub(min).div(step).toNumber());
+  let upCount = Math.ceil(new Decimal(max).sub(middle).div(step).toNumber());
+  const scaleCount = belowCount + upCount + 1;
+
+  if (scaleCount > tickCount) {
+    // When more ticks need to cover the interval, step should be bigger.
+    return calculateStep(min, max, tickCount, allowDecimals, correctionFactor + 1, stepFn);
+  }
+  if (scaleCount < tickCount) {
+    // When less ticks can cover the interval, we should add some additional ticks
+    upCount = max > 0 ? upCount + (tickCount - scaleCount) : upCount;
+    belowCount = max > 0 ? belowCount : belowCount + (tickCount - scaleCount);
+  }
+
+  return {
+    step,
+    tickMin: middle.sub(new Decimal(belowCount).mul(step)),
+    tickMax: middle.add(new Decimal(upCount).mul(step)),
+  };
+};
+
+/**
+ * Calculate the ticks of an interval. Ticks can appear outside the interval
+ * if it makes them more rounded and nice.
+ *
+ * @param tuple of [min,max] min: The minimum value, max: The maximum value
+ * @param tickCount     The count of ticks
+ * @param allowDecimals Allow the ticks to be decimals or not
+ * @param niceTicksMode The algorithm to use for calculating nice ticks.
+ * @return array of ticks
+ */
+export const getNiceTickValues = (
+  [min, max]: NumberDomain,
+  tickCount = 6,
+  allowDecimals = true,
+  niceTicksMode: NiceTicksAlgorithm = "auto",
+): number[] => {
+  // More than two ticks should be return
+  const count = Math.max(tickCount, 2);
+  const [cormin, cormax] = getValidInterval([min, max]);
+
+  if (cormin === -Infinity || cormax === Infinity) {
+    const values: Array<number> =
+      cormax === Infinity
+        ? [cormin, ...Array<number>(tickCount - 1).fill(Infinity)]
+        : [...Array<number>(tickCount - 1).fill(-Infinity), cormax];
+
+    return min > max ? values.reverse() : values;
+  }
+
+  if (cormin === cormax) {
+    return getTickOfSingleValue(cormin, tickCount, allowDecimals);
+  }
+
+  const stepFn = niceTicksMode === "snap125" ? getSnap125Step : getAdaptiveStep;
+
+  // Get the step between two ticks
+  const { step, tickMin, tickMax } = calculateStep(cormin, cormax, count, allowDecimals, 0, stepFn);
+
+  const values = rangeStep(tickMin, tickMax.add(new Decimal(0.1).mul(step)), step);
+
+  return min > max ? values.reverse() : values;
+};
+
+/**
+ * Calculate the ticks of an interval.
+ * Ticks will be constrained to the interval [min, max] even if it makes them less rounded and nice.
+ *
+ * @param tuple of [min,max] min: The minimum value, max: The maximum value
+ * @param tickCount     The count of ticks. This function may return less than tickCount ticks if the interval is too small.
+ * @param allowDecimals Allow the ticks to be decimals or not
+ * @param niceTicksMode          The algorithm to use for calculating nice ticks. See {@link NiceTicksAlgorithm}.
+ * @return array of ticks
+ */
+export const getTickValuesFixedDomain = (
+  [min, max]: NumberDomain,
+  tickCount: number,
+  allowDecimals = true,
+  niceTicksMode: NiceTicksAlgorithm = "auto",
+) => {
+  // More than two ticks should be return
+  const [cormin, cormax] = getValidInterval([min, max]);
+
+  if (cormin === -Infinity || cormax === Infinity) {
+    return [min, max];
+  }
+
+  if (cormin === cormax) {
+    return [cormin];
+  }
+
+  const stepFn = niceTicksMode === "snap125" ? getSnap125Step : getAdaptiveStep;
+  const count = Math.max(tickCount, 2);
+  const step = stepFn(new Decimal(cormax).sub(cormin).div(count - 1), allowDecimals, 0);
+  let values = [...rangeStep(new Decimal(cormin), new Decimal(cormax), step), cormax];
+
+  if (allowDecimals === false) {
+    /*
+     * allowDecimals is false means that we want to have integer ticks.
+     * The step is guaranteed to be an integer in the code above which is great start
+     * but when the first step is not an integer, it will start stepping from a decimal value anyway.
+     * So we need to round all the values to integers after the fact.
+     * The domain boundary (cormax) is appended after the rangeStep values. When
+     * cormax rounds down to the same integer as the last rangeStep value, we end up
+     * with a duplicate trailing tick. Remove it.
+     */
+    values = values.map((value) => Math.round(value));
+    const last = values.length - 1;
+    if (last > 0 && values[last] === values[last - 1]) {
+      values = values.slice(0, last);
+    }
+  }
+
+  return min > max ? values.reverse() : values;
+};