solid-recharts 1.0.0 → 2.0.0-beta.1

package/test/util/isDomainSpecifiedByUser.spec.ts

@@ -0,0 +1,207 @@
+// Ported from recharts 3.8.1 test/util/isDomainSpecifiedByUser.spec.ts (commit 7a23854).
+// Pure-function unit test: import the functions and assert. No render/diagnostics.
+
+import {
+  numericalDomainSpecifiedWithoutRequiringData,
+  parseNumericalUserDomain,
+} from "../../src/util/isDomainSpecifiedByUser";
+import { AxisDomain, NumberDomain } from "../../src/util/types";
+
+// I need to add object wrapper because Jest likes to sometimes auto-flatten arrays of arrays
+type MyTestCases = ReadonlyArray<{ domain: AxisDomain; expected?: NumberDomain }>;
+
+describe("parsing axis domain provided by user", () => {
+  // These are valid domains without any further questions and without the need for calculated data domain as an input
+  const validCases: MyTestCases = [
+    { domain: [-100, 100], expected: [-100, 100] },
+    { domain: [-5, 0], expected: [-5, 0] },
+    { domain: [0, 100], expected: [0, 100] },
+    { domain: [100, 100], expected: [100, 100] },
+    /*
+     * I am surprised, but in Recharts it is valid to have domain where first element is larger than the second!
+     * This also makes the axis reversed.
+     */
+    { domain: [2, 1], expected: [2, 1] },
+  ];
+
+  const casesThatDefaultToDataMinDataMax: MyTestCases = [
+    { domain: [NaN, NaN] },
+    // sorry no string parsing. Although we could allow that, why not? Perhaps an opportunity for an improvement
+    { domain: ["20", "30"] },
+    { domain: ["", ""] },
+    // no percents in dataMin or dataMax, possible feature request perhaps
+    { domain: ["dataMin - 10%", "dataMax + 5%"] },
+    /*
+     * This is interesting - Recharts allows dataMin to get smaller and dataMax to get bigger,
+     * but doesn't allow dataMin to get bigger and dataMax to get smaller!
+     * Even with allowDataOverflow = true.
+     */
+    { domain: ["dataMin + 11.2", "dataMax - 7.3"], expected: [-100, 100] },
+  ];
+
+  // These are always invalid domains
+  const invalidCases: MyTestCases = [
+    { domain: [] },
+    { domain: [0] },
+    { domain: [100, 150, 200] },
+    { domain: [0, Infinity] },
+    { domain: [Infinity, 9] },
+    { domain: [() => "1", 9] },
+    // @ts-expect-error typescript is correct here, but I want a test anyway
+    { domain: () => ["1", 9] },
+    // @ts-expect-error typescript is correct here, but I want a test anyway
+    { domain: () => [1, 2, 3] },
+    // toFixed returns a string and strings are not allowed
+    { domain: [(min: number) => min.toFixed(3), (max: number) => max.toFixed(3)] },
+  ];
+
+  const numericalDataDomain: NumberDomain = [-100, 100];
+
+  /**
+   * These are valid - but only when the calculated chart data is present.
+   */
+  const casesValidOnlyWhenDataDomainIsGiven: MyTestCases = [
+    { domain: [() => 1, () => 2], expected: [1, 2] },
+    { domain: () => [3, 4], expected: [3, 4] },
+    { domain: [() => 1, 9], expected: [1, 9] },
+    { domain: [100, NaN], expected: [100, 100] },
+    { domain: [NaN, 200], expected: [-100, 200] },
+    { domain: [11, "auto"], expected: [11, 100] },
+    { domain: ["auto", 1], expected: [-100, 1] },
+    { domain: [0, "dataMax"], expected: [0, 100] },
+    { domain: ["dataMin", "dataMax"], expected: [-100, 100] },
+    { domain: ["auto", "auto"], expected: [-100, 100] },
+    { domain: ["dataMin - 11.2", "dataMax + 7.3"], expected: [-111.2, 107.3] },
+    { domain: (d) => [Math.min(...d), 999], expected: [-100, 999] },
+    { domain: (d) => [d[0] - 21, d[1] + 23], expected: [-121, 123] },
+    {
+      domain: [(min: number) => min.valueOf() - 17, (max: number) => max / 2],
+      expected: [-117, 50],
+    },
+  ];
+
+  /**
+   * These are valid - but the prop allowDataOverflow = false means that
+   * recharts should ignore what user returned, and use the data domain instead.
+   */
+  const casesWithDomainSmallerThanData: MyTestCases = [
+    { domain: [11, 200], expected: [-100, 200] },
+    { domain: [11, "auto"], expected: [-100, 100] },
+    { domain: ["auto", 1], expected: [-100, 100] },
+    { domain: [0, "dataMax"], expected: [-100, 100] },
+    { domain: (d) => [Math.min(...d), 0], expected: [-100, 100] },
+    {
+      domain: [(min: number) => min.valueOf() + 17, (max: number) => max / 2],
+      expected: [-100, 100],
+    },
+  ];
+
+  describe("numericalDomainSpecifiedWithoutRequiringData", () => {
+    it.each([true, false])(
+      "should return undefined when user input is undefined and allowDataOverflow = %s",
+      (allowDataOverflow) => {
+        expect(
+          numericalDomainSpecifiedWithoutRequiringData(undefined, allowDataOverflow),
+        ).toBeUndefined();
+        expect(
+          numericalDomainSpecifiedWithoutRequiringData(undefined, allowDataOverflow),
+        ).toBeUndefined();
+      },
+    );
+
+    it.each(validCases)(
+      "should return $expected when domain = $domain and allowDataOverflow = true",
+      ({ domain, expected }) => {
+        expect(numericalDomainSpecifiedWithoutRequiringData(domain, true)).toEqual(expected);
+      },
+    );
+
+    it.each(validCases)(
+      "should return undefined when domain = $domain and allowDataOverflow = false",
+      ({ domain }) => {
+        expect(numericalDomainSpecifiedWithoutRequiringData(domain, false)).toEqual(undefined);
+      },
+    );
+
+    it.each(invalidCases)("should return undefined when domain = $domain", ({ domain }) => {
+      expect(numericalDomainSpecifiedWithoutRequiringData(domain, true)).toEqual(undefined);
+      expect(numericalDomainSpecifiedWithoutRequiringData(domain, false)).toEqual(undefined);
+    });
+
+    it.each(casesThatDefaultToDataMinDataMax)(
+      "should return undefined when domain = $domain",
+      ({ domain }) => {
+        expect(numericalDomainSpecifiedWithoutRequiringData(domain, true)).toEqual(undefined);
+        expect(numericalDomainSpecifiedWithoutRequiringData(domain, false)).toEqual(undefined);
+      },
+    );
+
+    it.each(casesValidOnlyWhenDataDomainIsGiven)(
+      "should return undefined when domain = $domain but data domain is undefined",
+      ({ domain }) => {
+        expect(numericalDomainSpecifiedWithoutRequiringData(domain, true)).toBeUndefined();
+        expect(numericalDomainSpecifiedWithoutRequiringData(domain, false)).toBeUndefined();
+      },
+    );
+  });
+
+  describe("parseNumericalUserDomain", () => {
+    it.each([true, false])(
+      "should return undefined when user input is undefined and allowDataOverflow = %s",
+      (allowDataOverflow) => {
+        expect(
+          parseNumericalUserDomain(undefined, numericalDataDomain, allowDataOverflow),
+        ).toBeUndefined();
+        expect(
+          parseNumericalUserDomain(undefined, numericalDataDomain, allowDataOverflow),
+        ).toBeUndefined();
+      },
+    );
+
+    it.each(validCases)(
+      "should return $expected when domain = $domain and allowDataOverflow = true",
+      ({ domain, expected }) => {
+        expect(parseNumericalUserDomain(domain, undefined, true)).toEqual(expected);
+      },
+    );
+
+    it.each(casesValidOnlyWhenDataDomainIsGiven)(
+      "should return $expected when domain = $domain",
+      ({ domain, expected }) => {
+        expect(parseNumericalUserDomain(domain, numericalDataDomain, true)).toEqual(expected);
+      },
+    );
+
+    it.each(casesValidOnlyWhenDataDomainIsGiven)(
+      "should return undefined when domain = $domain and data is undefined",
+      ({ domain }) => {
+        expect(parseNumericalUserDomain(domain, undefined, true)).toEqual(undefined);
+        expect(parseNumericalUserDomain(domain, undefined, false)).toEqual(undefined);
+      },
+    );
+
+    it.each(casesWithDomainSmallerThanData)(
+      "should extend the domain to $expected when domain = $domain and allowDataOverflow = false",
+      ({ domain, expected }) => {
+        expect(parseNumericalUserDomain(domain, numericalDataDomain, false)).toEqual(expected);
+      },
+    );
+
+    it.each(invalidCases)("should return undefined when domain = $domain", ({ domain }) => {
+      expect(parseNumericalUserDomain(domain, numericalDataDomain, true)).toBeUndefined();
+      expect(parseNumericalUserDomain(domain, numericalDataDomain, false)).toBeUndefined();
+      expect(parseNumericalUserDomain(domain, undefined, true)).toBeUndefined();
+      expect(parseNumericalUserDomain(domain, undefined, false)).toBeUndefined();
+    });
+
+    it.each(casesThatDefaultToDataMinDataMax)(
+      "should return data min, data max when domain = $domain",
+      ({ domain }) => {
+        expect(parseNumericalUserDomain(domain, numericalDataDomain, true)).toEqual([-100, 100]);
+        expect(parseNumericalUserDomain(domain, numericalDataDomain, false)).toEqual([-100, 100]);
+        expect(parseNumericalUserDomain(domain, undefined, true)).toBeUndefined();
+        expect(parseNumericalUserDomain(domain, undefined, false)).toBeUndefined();
+      },
+    );
+  });
+});

package/test/util/isWellBehavedNumber.spec.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from "vitest";
+import { isPositiveNumber, isWellBehavedNumber } from "../../src/util/isWellBehavedNumber";
+
+describe("isWellBehavedNumber", () => {
+  it.each([
+    [false, null],
+    [false, undefined],
+    [false, "a"],
+    [false, "1"],
+    [false, NaN],
+    [false, Symbol("a")],
+    [false, []],
+    [false, {}],
+    [false, () => {}],
+    [false, new Date()],
+    [false, new Map()],
+    [false, new Set()],
+    [false, Infinity],
+    [false, -Infinity],
+    [true, -0],
+    [true, 3],
+    [true, -3],
+    [true, -3.1],
+    [true, 0.1],
+  ])("should return %s when the input is %s", (expected, value) => {
+    expect(isWellBehavedNumber(value)).toBe(expected);
+  });
+});
+
+describe("isPositiveNumber", () => {
+  it.each([
+    [false, null],
+    [false, undefined],
+    [false, "a"],
+    [false, "1"],
+    [false, NaN],
+    [false, Symbol("a")],
+    [false, []],
+    [false, {}],
+    [false, () => {}],
+    [false, new Date()],
+    [false, new Map()],
+    [false, new Set()],
+    [false, -Infinity],
+    [false, 0],
+    [false, -0],
+    [false, -3.1],
+    [false, -0.1],
+    [true, 3],
+    [true, 3.1],
+  ])("should return %s when the input is %s", (expected, value) => {
+    expect(isPositiveNumber(value)).toBe(expected);
+  });
+});

package/test/util/payload/getUniqPayload.spec.ts

@@ -0,0 +1,56 @@
+import { getUniqPayload } from "../../../src/util/payload/getUniqPayload";
+
+type ExamplePayload = { name: string; value: number };
+
+const payload = [
+  {
+    name: "a",
+    value: 5,
+  },
+  {
+    name: "b",
+    value: 5,
+  },
+  {
+    name: "a",
+    value: 7,
+  },
+];
+
+const defaultUniqBy = (o: ExamplePayload) => o.name;
+
+describe("getUniqPayload", () => {
+  it("should return payload as-is if iteratee is false", () => {
+    const result = getUniqPayload(payload, false, defaultUniqBy);
+    expect(result).toBe(payload);
+  });
+
+  it("should use defaultUniqBy parameter if iteratee is true", () => {
+    const result = getUniqPayload(payload, true, defaultUniqBy);
+    expect(result).toEqual([
+      {
+        name: "a",
+        value: 5,
+      },
+      {
+        name: "b",
+        value: 5,
+      },
+    ]);
+  });
+
+  it("should use iteratee if it is a function", () => {
+    const customIteratee = (o: ExamplePayload) => o.value;
+    const result = getUniqPayload(payload, customIteratee, defaultUniqBy);
+    expect(result).toEqual([
+      {
+        name: "a",
+        value: 5,
+      },
+      {
+        name: "a",
+        value: 7,
+      },
+    ]);
+  });
+});

package/test/util/propsAreEqual.spec.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect } from "vitest";
+import { propsAreEqual } from "../../src/util/propsAreEqual";
+
+describe("propsAreEqual", () => {
+  it("should return true for identical props", () => {
+    const props1 = { a: 1, b: "test", c: true };
+    const props2 = { a: 1, b: "test", c: true };
+    expect(propsAreEqual(props1, props2)).toBe(true);
+  });
+
+  it("should return false for different props", () => {
+    const props1 = { a: 1, b: "test", c: true };
+    const props2 = { a: 2, b: "test", c: true };
+    expect(propsAreEqual(props1, props2)).toBe(false);
+  });
+
+  it("should return false for different nested props", () => {
+    const props1 = { a: 1, b: { x: 10, y: 20 } };
+    const props2 = { a: 1, b: { x: 10, y: 30 } };
+    expect(propsAreEqual(props1, props2)).toBe(false);
+  });
+
+  it("should return true for same reference nested props", () => {
+    const nested = { x: 10, y: 20 };
+    const props1 = { a: 1, b: nested };
+    const props2 = { a: 1, b: nested };
+    expect(propsAreEqual(props1, props2)).toBe(true);
+  });
+
+  it("should return true for same value, different reference, allowlisted nested props", () => {
+    // dot is one of the special allowlisted props for shallow comparison
+    const props1 = { a: 1, dot: { x: 10, y: 20 } };
+    const props2 = { a: 1, dot: { x: 10, y: 20 } };
+    expect(propsAreEqual(props1, props2)).toBe(true);
+  });
+
+  it("should return false for different value, different reference, allowlisted nested props", () => {
+    /*
+     * dot is one of the special allowlisted props for shallow comparison
+     * but the values differ
+     */
+    const props1 = { a: 1, dot: { x: 10, y: 20 } };
+    const props2 = { a: 1, dot: { x: 10, y: 30 } };
+    expect(propsAreEqual(props1, props2)).toBe(false);
+  });
+
+  it("should treat undefined and null as if they were equal", () => {
+    type TestProps = { a?: number | null; b?: number | null };
+    const props1: TestProps = { a: undefined, b: null };
+    const props2: TestProps = { a: null, b: undefined };
+    expect(propsAreEqual(props1, props2)).toBe(true);
+  });
+
+  it("should treat positive and negative zero as equal", () => {
+    const props1 = { a: 0 };
+    const props2 = { a: -0 };
+    expect(propsAreEqual(props1, props2)).toBe(true);
+  });
+
+  it("should treat NaN values as equal", () => {
+    const props1 = { a: NaN };
+    const props2 = { a: NaN };
+    expect(propsAreEqual(props1, props2)).toBe(true);
+  });
+
+  it.each(["data", "points"])("should not attempt to shallow compare prop %s", (propName) => {
+    /*
+     * Let's specifically test that these props are not shallowly compared because these should not be allowlisted!
+     * We can receive large arrays/objects here that would be too costly to compare.
+     */
+    const props1 = { a: 1, [propName]: { x: 10, y: 20 } };
+    const props2 = { a: 1, [propName]: { x: 10, y: 30 } };
+    expect(propsAreEqual(props1, props2)).toBe(false);
+  });
+});

package/test/util/round.spec.ts

@@ -0,0 +1,112 @@
+import { describe, it, expect } from "vitest";
+import { round, roundTemplateLiteral } from "../../src/util/round";
+
+describe("round", () => {
+  it("should round a number to default precision of 4", () => {
+    expect(round(1.23456789)).toBe(1.2346);
+    expect(round(5.67891234)).toBe(5.6789);
+  });
+
+  it("should round a number to specified precision", () => {
+    expect(round(1.23456789, 0)).toBe(1);
+    expect(round(1.23456789, 1)).toBe(1.2);
+    expect(round(1.23456789, 2)).toBe(1.23);
+    expect(round(1.23456789, 3)).toBe(1.235);
+    expect(round(1.23456789, 5)).toBe(1.23457);
+  });
+
+  it("should handle negative numbers", () => {
+    expect(round(-1.23456789, 4)).toBe(-1.2346);
+    expect(round(-5.6789, 2)).toBe(-5.68);
+  });
+
+  it("should convert -0 to 0", () => {
+    expect(round(-0.0001, 3)).toBe(0);
+    expect(Object.is(round(-0.0001, 3), -0)).toBe(false);
+    expect(Object.is(round(-0.0001, 3), 0)).toBe(true);
+  });
+
+  it("should handle zero", () => {
+    expect(round(0)).toBe(0);
+    expect(round(0, 2)).toBe(0);
+  });
+
+  it("should handle integers", () => {
+    expect(round(42)).toBe(42);
+    expect(round(100, 2)).toBe(100);
+  });
+
+  it("should handle very small numbers", () => {
+    expect(round(0.00001, 4)).toBe(0);
+    expect(round(0.00001, 5)).toBe(0.00001);
+    expect(round(0.00001, 6)).toBe(0.00001);
+    expect(round(1e-15, 6)).toBe(0);
+  });
+
+  it("should handle very large numbers", () => {
+    // eslint-disable-next-line no-loss-of-precision
+    expect(round(123456789.123456789, 2)).toBe(123456789.12);
+    expect(round(999999.999999, 4)).toBe(1000000);
+  });
+
+  it("should handle edge case rounding", () => {
+    expect(round(1.5, 0)).toBe(2);
+    expect(round(2.5, 0)).toBe(3);
+    expect(round(-1.5, 0)).toBe(-1);
+    expect(round(-2.5, 0)).toBe(-2);
+  });
+});
+
+describe("roundTemplateLiteral", () => {
+  it("should round values in template literal", () => {
+    const result = roundTemplateLiteral`M${10.123456},${20.987654}L${30.555555},${40.444444}`;
+    expect(result).toBe("M10.1235,20.9877L30.5556,40.4444");
+  });
+
+  it("should handle template with no values", () => {
+    const result = roundTemplateLiteral`M10,20L30,40`;
+    expect(result).toBe("M10,20L30,40");
+  });
+
+  it("should handle template with single value", () => {
+    const result = roundTemplateLiteral`M${10.123456},20`;
+    expect(result).toBe("M10.1235,20");
+  });
+
+  it("should handle negative values", () => {
+    const result = roundTemplateLiteral`M${-10.123456},${-20.987654}`;
+    expect(result).toBe("M-10.1235,-20.9877");
+  });
+
+  it("should handle zero values", () => {
+    const result = roundTemplateLiteral`M${0},${0}L${0.0001},${-0.0001}`;
+    expect(result).toBe("M0,0L0.0001,-0.0001");
+  });
+
+  it("should handle integers", () => {
+    const result = roundTemplateLiteral`M${10},${20}L${30},${40}`;
+    expect(result).toBe("M10,20L30,40");
+  });
+
+  it("should handle SVG path with multiple commands", () => {
+    const result = roundTemplateLiteral`M${10.1111},${20.2222}L${30.3333},${40.4444}Q${50.5555},${60.6666},${70.7777},${80.8888}Z`;
+    expect(result).toBe("M10.1111,20.2222L30.3333,40.4444Q50.5555,60.6666,70.7777,80.8888Z");
+  });
+
+  it("should handle empty string parts", () => {
+    const x = 10.12345;
+    const y = 20.6789;
+    const result = roundTemplateLiteral`${x},${y}`;
+    expect(result).toBe("10.1235,20.6789");
+  });
+
+  it("should preserve spacing and formatting", () => {
+    const result = roundTemplateLiteral`M ${10.123456} ${20.987654} L ${30.555555} ${40.444444}`;
+    expect(result).toBe("M 10.1235 20.9877 L 30.5556 40.4444");
+  });
+
+  it("should allow string values without rounding", () => {
+    const result = roundTemplateLiteral`M${10.123456},${"20.987654"}L${"30.555555"},${40.444444}`;
+    expect(result).toBe("M10.1235,20.987654L30.555555,40.4444");
+  });
+});

package/test/util/scale/arithmetic.spec.ts

@@ -0,0 +1,61 @@
+import { describe, expect } from "vitest";
+// Uses the lib's own DecimalLite (decimal.js-light replacement) so spec args
+// are the same Decimal type the implementation operates on.
+import Decimal from "../../../src/util/scale/util/DecimalLite";
+import { getDigitCount, rangeStep } from "../../../src/util/scale/util/arithmetic";
+
+describe("arithmetic", () => {
+  describe("getDigitCount", () => {
+    it("should return 1 for value equals 0)", () => {
+      expect(getDigitCount(0)).toBe(1);
+    });
+
+    it("should return 0 for value in [0.1, 1)", () => {
+      expect(getDigitCount(0.1)).toBe(0);
+      expect(getDigitCount(0.5)).toBe(0);
+    });
+
+    it("should return -1 for value in [0,01, 0.1)", () => {
+      expect(getDigitCount(0.01)).toBe(-1);
+      expect(getDigitCount(0.05)).toBe(-1);
+    });
+
+    it("should return -2 for value in [0.001, 0.01)", () => {
+      expect(getDigitCount(0.001)).toBe(-2);
+      expect(getDigitCount(0.005)).toBe(-2);
+    });
+
+    it("should return 2 for value in [10, 100)", () => {
+      expect(getDigitCount(10)).toBe(2);
+      expect(getDigitCount(99)).toBe(2);
+    });
+
+    it("should return correct digit count for large numbers", () => {
+      expect(getDigitCount(1.1e21)).toBe(22);
+    });
+
+    it("should return correct digit count for small numbers", () => {
+      expect(getDigitCount(1.1e-21)).toBe(-20);
+    });
+  });
+
+  describe("rangeStep", () => {
+    it("should generate correct range steps", () => {
+      const result = rangeStep(new Decimal(0), new Decimal(5), new Decimal(1));
+      expect(result).toEqual([0, 1, 2, 3, 4]);
+    });
+
+    it("should generate correct decimal range steps", () => {
+      const result = rangeStep(new Decimal(0), new Decimal(1), new Decimal(0.1));
+      expect(result).toEqual([0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]);
+    });
+
+    it("should generate correct decimal range steps with small values", () => {
+      const result = rangeStep(new Decimal(0), new Decimal(0.0000035), new Decimal(0.00000035));
+      expect(result).toEqual([
+        0, 0.00000035, 0.0000007, 0.00000105, 0.0000014, 0.00000175, 0.0000021, 0.00000245,
+        0.0000028, 0.00000315,
+      ]);
+    });
+  });
+});

package/test/util/scale/createCategoricalInverse.spec.ts

@@ -0,0 +1,84 @@
+// Ported from recharts 3.8.1 test/util/scale/createCategoricalInverse.spec.ts (commit 7a23854).
+import { describe, it, expect } from "vitest";
+import { scaleLinear } from "d3-scale";
+import { bisect, createCategoricalInverse } from "../../../src/util/scale/createCategoricalInverse";
+import { CustomScaleDefinition } from "../../../src/util/scale/CustomScaleDefinition";
+
+describe("bisect", () => {
+  it("should return the correct insertion index in an ascending array", () => {
+    const haystack = [1, 3, 5, 7, 9];
+    expect(bisect(haystack, 0)).toBe(0);
+    expect(bisect(haystack, 4)).toBe(2);
+    expect(bisect(haystack, 10)).toBe(5);
+  });
+
+  it("should return the correct insertion index in a descending array", () => {
+    const haystack = [9, 7, 5, 3, 1];
+    expect(bisect(haystack, 10)).toBe(0);
+    expect(bisect(haystack, 6)).toBe(2);
+    expect(bisect(haystack, 0)).toBe(5);
+  });
+
+  it("should return 0 when the haystack has two identical elements", () => {
+    const haystack = [5, 5];
+    expect(bisect(haystack, 5)).toBe(0);
+  });
+
+  it("should return 0 for an empty array", () => {
+    const haystack: number[] = [];
+    expect(bisect(haystack, 5)).toBe(0);
+  });
+
+  it("should return 0 for a single-element array", () => {
+    const haystack = [3];
+    expect(bisect(haystack, 5)).toBe(0);
+  });
+});
+
+describe("createCategoricalInverse", () => {
+  it("should return undefined when scale is undefined", () => {
+    const actual = createCategoricalInverse(undefined);
+    expect(actual).toBeUndefined();
+  });
+
+  it("should return undefined when domain is empty", () => {
+    // @ts-expect-error this type forces strings into a number scale
+    const mockScale: CustomScaleDefinition = scaleLinear().domain([]).range([0, 100]);
+    const actual = createCategoricalInverse(mockScale);
+    expect(actual).toBeUndefined();
+  });
+
+  it("should return undefined when range has less than two elements", () => {
+    // @ts-expect-error this type forces strings into a number scale
+    const mockScale: CustomScaleDefinition = scaleLinear().domain([0, 1]).range([0]);
+    const actual = createCategoricalInverse(mockScale);
+    expect(actual).toBeUndefined();
+  });
+
+  it("should return a function that maps pixel values to domain values", () => {
+    // @ts-expect-error this type forces strings into a number scale
+    const mockScale: CustomScaleDefinition = scaleLinear().domain([0, 2]).range([0, 100]);
+    const inverse = createCategoricalInverse(mockScale);
+    expect(inverse).toBeDefined();
+    if (inverse) {
+      expect(inverse(0)).toBe(0);
+      expect(inverse(50)).toBe(0);
+      expect(inverse(75)).toBe(2);
+      expect(inverse(100)).toBe(2);
+    }
+  });
+
+  it("should use allDataPointsOnAxis if provided", () => {
+    // @ts-expect-error this type forces strings into a number scale
+    const mockScale: CustomScaleDefinition = scaleLinear().domain([0, 2]).range([0, 100]);
+    const allDataPoints = [0, 1, 2];
+    const inverse = createCategoricalInverse(mockScale, allDataPoints);
+    expect(inverse).toBeDefined();
+    if (inverse) {
+      expect(inverse(0)).toBe(0);
+      expect(inverse(45)).toBe(1);
+      expect(inverse(75)).toBe(1);
+      expect(inverse(100)).toBe(2);
+    }
+  });
+});