solid-recharts 0.2.1 → 1.0.0

package/test/util/isDomainSpecifiedByUser.spec.ts

@@ -1,207 +0,0 @@
-// 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

@@ -1,54 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,84 +0,0 @@
-// 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);
-    }
-  });
-});