solid-recharts 0.1.0 → 0.2.1

package/test/polar/Radar.render.spec.tsx

@@ -9,7 +9,7 @@
 // tooltip/legend deferred.
 import { describe, expect, it } from "vitest";
 import { flush } from "solid-js";
-import { render } from "../helper/render";
+import { render } from "@solidjs/testing-library";
 import { RadarChart, Radar, PolarAngleAxis } from "../../src";
 
 const exampleRadarData = [

package/test/polar/Radar.spec.tsx

@@ -11,7 +11,7 @@ import { describe, expect, it, vi } from "vitest";
 import { Radar, RadarChart } from "../../src";
 import type { RadarProps } from "../../src";
 import type { RadarShapeProps } from "../../src/polar/Radar";
-import { fireEvent, render, screen } from "../helper/render";
+import { fireEvent, render, screen } from "@solidjs/testing-library";
 import { useAppSelector } from "../../src/state/hooks";
 import { selectPolarItemsSettings } from "../../src/state/selectors/polarSelectors";
 import { exampleRadarData } from "../_data";

package/test/polar/Radar.typed.spec.tsx

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { Radar, RadarChart, getRelativeCoordinate } from "../../src";
-import { render } from "../helper/render";
+import { render } from "@solidjs/testing-library";
 
 type ExampleDataPoint = {
   value: number;

package/test/polar/RadialBar/RadialBar.spec.tsx

@@ -28,7 +28,7 @@ import {
   Tooltip,
 } from "../../../src";
 import { assertZIndexLayerOrder } from "../../helper/assertZIndexLayerOrder";
-import { fireEvent, render } from "../../helper/render";
+import { fireEvent, render } from "@solidjs/testing-library";
 import { useAppSelector } from "../../../src/state/hooks";
 import { selectPolarItemsSettings } from "../../../src/state/selectors/polarSelectors";
 import { PageData } from "../../_data";

package/test/polar/RadialBar/RadialBar.typed.spec.tsx

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "vitest";
 import type { RadialBarDataItem } from "../../../src";
 import { getRelativeCoordinate, RadialBar, RadialBarChart } from "../../../src";
-import { render } from "../../helper/render";
+import { render } from "@solidjs/testing-library";
 
 type ExampleDataPoint = {
   value: number;

package/test/polar/RadialBar.animation.spec.tsx

@@ -23,7 +23,7 @@
 import { describe, expect, it, vi } from "vitest";
 import type { JSX } from "@solidjs/web";
 import { createSignal, flush } from "solid-js";
-import { render, fireEvent } from "../helper/render";
+import { render, fireEvent } from "@solidjs/testing-library";
 import { assertNotNull } from "../helper/assertNotNull";
 import { trim } from "../helper/trim";
 import { RadialBarChart, RadialBar } from "../../src";

package/test/polar/RadialBar.render.spec.tsx

@@ -8,7 +8,7 @@
 // animation/label/exact geometry deferred.
 import { describe, expect, it } from "vitest";
 import { flush } from "solid-js";
-import { render } from "../helper/render";
+import { render } from "@solidjs/testing-library";
 import { RadialBarChart, RadialBar } from "../../src";
 import { PageData } from "../_data";
 

package/test/polar/RadialBar.stacked.spec.tsx

@@ -4,7 +4,7 @@
 // [570,1830]→[56°,180°] with endAngle=180 and total=1830).
 import { describe, expect, it } from "vitest";
 import { flush } from "solid-js";
-import { render } from "../helper/render";
+import { render } from "@solidjs/testing-library";
 import { RadialBarChart, RadialBar } from "../../src";
 
 const data = [{ month: "january", desktop: 1260, mobile: 570 }];

package/test/setup.ts

@@ -30,7 +30,7 @@ import "@testing-library/jest-dom/vitest";
 import "./helper/expectFunctionReturning";
 import { afterEach, beforeEach, vi } from "vitest";
 import { DEV } from "solid-js";
-import { cleanup } from "./helper/render";
+import { cleanup } from "@solidjs/testing-library";
 import {
   type DiagnosticEvent,
   describeDiagnosticEvents,

package/test/shape/ActiveShape.spec.tsx

@@ -18,7 +18,7 @@
 // upstream cases are omitted. The function, object, and boolean forms are ported
 // verbatim (modulo className->class).
 import { describe, expect, test } from "vitest";
-import { render } from "../helper/render";
+import { render } from "@solidjs/testing-library";
 import { Funnel, FunnelChart, Trapezoid, Tooltip } from "../../src";
 import { showTooltip } from "../component/Tooltip/tooltipTestHelpers";
 import { funnelChartMouseHoverTooltipSelector } from "../component/Tooltip/tooltipMouseHoverSelectors";

package/test/shape/Cross.spec.tsx

@@ -3,7 +3,7 @@
 // import; the invalid-input cast uses `unknown` instead of `any`. Assertions
 // are byte-identical (snapshots self-record our output; the `.recharts-cross`
 // counts are the parity signal).
-import { render } from "../helper/render";
+import { render } from "@solidjs/testing-library";
 
 import { Surface, Cross } from "../../src";
 

package/test/shape/Curve.spec.tsx

@@ -4,8 +4,8 @@
 // render takes a thunk. All assertions are byte-identical.
 import { describe, expect, it, test } from "vitest";
 import { createSignal } from "solid-js";
-import { render, fireEvent } from "../helper/render";
-import { curveLinear } from "victory-vendor/d3-shape";
+import { render, fireEvent } from "@solidjs/testing-library";
+import { curveLinear } from "d3-shape";
 import { Surface, Curve } from "../../src";
 import { getPath, type CurveType } from "../../src/shape/Curve";
 import { assertNotNull } from "../helper/assertNotNull";

package/test/shape/Curve.typed.spec.tsx

@@ -19,7 +19,7 @@
  *   `(_curveProps, e)` React signature is reported in blocked.)
  */
 import { describe, it } from "vitest";
-import { render } from "@solid-recharts/testing-library";
+import { render } from "@solidjs/testing-library";
 import { Curve, getRelativeCoordinate } from "../../src";
 
 describe("Curve types", () => {

package/test/shape/Dot.spec.tsx

@@ -2,7 +2,7 @@
 // Harness changes only: render from local Solid shim, no React import, render takes a thunk.
 // All assertions are byte-identical to recharts.
 import { describe, test, expect } from "vitest";
-import { render } from "../helper/render";
+import { render } from "@solidjs/testing-library";
 
 import { Surface, Dot } from "../../src";
 import { assertNotNull } from "../helper/assertNotNull";

package/test/shape/Polygon.spec.tsx

@@ -2,7 +2,7 @@
 // Harness changes only: render/fireEvent from the local Solid shim (thunk), no
 // React import; `className` → `class` (the sanctioned prop rename). Path `d`
 // assertions are byte-identical (the parity signal); snapshots self-record.
-import { render, fireEvent } from "../helper/render";
+import { render, fireEvent } from "@solidjs/testing-library";
 import { Surface, Polygon } from "../../src";
 import { Coordinate } from "../../src/util/types";
 import { assertNotNull } from "../helper/assertNotNull";

package/test/shape/Rectangle.animation.spec.tsx

@@ -37,7 +37,7 @@
 //     is preserved.
 import { beforeAll, afterAll, describe, expect, it } from "vitest";
 import { createSignal, flush } from "solid-js";
-import { render } from "../helper/render";
+import { render } from "@solidjs/testing-library";
 import { trim } from "../helper/trim";
 import { assertNotNull } from "../helper/assertNotNull";
 import { Rectangle, Surface } from "../../src";

package/test/shape/Rectangle.spec.tsx

@@ -2,7 +2,7 @@
 // Harness changes only: render from the local Solid shim (thunk), no React
 // import; invalid-input casts use `unknown`. These all exercise the static
 // (non-update-animation) path. Path `d`/arc assertions are byte-identical.
-import { render } from "../helper/render";
+import { render } from "@solidjs/testing-library";
 import { Surface, Rectangle } from "../../src";
 import { RectRadius } from "../../src/shape/Rectangle";
 

package/test/shape/Sector.spec.tsx

@@ -2,7 +2,7 @@
 // Harness changes only: render from the local Solid shim (thunk), no React
 // import. Assertions are byte-identical (snapshots self-record; the
 // `.recharts-sector` presence/count + arc-count are the parity signal).
-import { render } from "../helper/render";
+import { render } from "@solidjs/testing-library";
 
 import { Surface, Sector } from "../../src";
 

package/test/shape/Symbols.spec.tsx

@@ -4,7 +4,7 @@
 // tests are ported; the 4th ('Expect no points attribute on path') renders a
 // full LineChart with XAxis/YAxis/Line and is DEFERRED until the chart vertical
 // is ported.
-import { render } from "../helper/render";
+import { render } from "@solidjs/testing-library";
 import { Surface, Symbols } from "../../src";
 
 describe("<Symbols />", () => {

package/test/shape/Trapezoid.spec.tsx

@@ -2,7 +2,7 @@
 // Harness changes only: render from the local Solid shim (thunk), no React
 // import. The 'with animation' case snapshot matches the reference byte-for-byte
 // (the update-animation path renders the t=0 frame with the "0px 1px" dash).
-import { render } from "../helper/render";
+import { render } from "@solidjs/testing-library";
 import { Surface, Trapezoid } from "../../src";
 
 describe("<Trapezoid />", () => {

package/test/state/createCollectionActions.spec.ts

@@ -0,0 +1,87 @@
+// Unit spec for the keyed-collection array algebra (src/state/createCollectionActions.ts).
+// No upstream counterpart — upstream inlines this per slice via immer; this pins
+// the shared contract the array slices (graphicalItems, referenceElements, legend,
+// tooltip) delegate to. The helper is pure over its read/write closures, so this
+// exercises it against a plain array cell — the interface is the test surface, and
+// the "new reference on every write" assertions are the ADR-0002 immutability
+// contract the reference-equality selector caches depend on.
+import { describe, expect, it } from "vitest";
+import { createCollectionActions } from "../../src/state/createCollectionActions";
+
+type Item = { id: string; v: number };
+
+function harness(initial: ReadonlyArray<Item> = []) {
+  let arr: ReadonlyArray<Item> = initial;
+  const actions = createCollectionActions<Item>(
+    (updater) => {
+      const next = updater(arr);
+      if (next !== arr) {
+        arr = next;
+      }
+    },
+    (it) => it.id,
+  );
+  return { actions, get: () => arr };
+}
+
+describe("createCollectionActions", () => {
+  it("add appends and produces a new array reference", () => {
+    const { actions, get } = harness();
+    const before = get();
+    actions.add({ id: "a", v: 1 });
+    expect(get()).toEqual([{ id: "a", v: 1 }]);
+    expect(get()).not.toBe(before);
+  });
+
+  it("replace swaps the matching element by key (new reference), keeping others and order", () => {
+    const { actions, get } = harness([
+      { id: "a", v: 1 },
+      { id: "b", v: 2 },
+    ]);
+    const before = get();
+    actions.replace({ prev: { id: "a", v: 1 }, next: { id: "a", v: 99 } });
+    expect(get()).toEqual([
+      { id: "a", v: 99 },
+      { id: "b", v: 2 },
+    ]);
+    expect(get()).not.toBe(before);
+  });
+
+  it("replace is a no-op (same reference) when the key is absent", () => {
+    const { actions, get } = harness([{ id: "a", v: 1 }]);
+    const before = get();
+    actions.replace({ prev: { id: "zzz", v: 0 }, next: { id: "zzz", v: 1 } });
+    expect(get()).toBe(before);
+  });
+
+  it("remove filters by key, new reference", () => {
+    const { actions, get } = harness([
+      { id: "a", v: 1 },
+      { id: "b", v: 2 },
+    ]);
+    const before = get();
+    actions.remove({ id: "a", v: 1 });
+    expect(get()).toEqual([{ id: "b", v: 2 }]);
+    expect(get()).not.toBe(before);
+  });
+
+  it("matches by keyOf, not object identity (nested key supported)", () => {
+    type Nested = { settings: { gid: string }; label: string };
+    let arr: ReadonlyArray<Nested> = [{ settings: { gid: "g1" }, label: "old" }];
+    const actions = createCollectionActions<Nested>(
+      (updater) => {
+        const next = updater(arr);
+        if (next !== arr) {
+          arr = next;
+        }
+      },
+      (n) => n.settings.gid,
+    );
+    // A different object carrying the SAME nested key still matches.
+    actions.replace({
+      prev: { settings: { gid: "g1" }, label: "whatever" },
+      next: { settings: { gid: "g1" }, label: "new" },
+    });
+    expect(arr).toEqual([{ settings: { gid: "g1" }, label: "new" }]);
+  });
+});

package/test/state/createSelector.spec.ts

@@ -0,0 +1,158 @@
+// Unit spec for the hand-rolled reselect-lite (ADR-0002). No upstream
+// counterpart to port — upstream gets this contract from reselect itself; this
+// spec pins the same contract for our implementation.
+import { describe, expect, it, vi } from "vitest";
+import { createMemo, createStore, flush } from "solid-js";
+import { renderHook } from "@solidjs/testing-library";
+import { createSelector } from "../../src/state/createSelector";
+
+type TestState = {
+  axis: { domain: readonly number[] };
+  data: { points: readonly number[] };
+  unrelated: { counter: number };
+};
+
+const makeState = (): TestState => ({
+  axis: { domain: [0, 1] },
+  data: { points: [1, 2, 3] },
+  unrelated: { counter: 0 },
+});
+
+describe("createSelector", () => {
+  it("shares one combiner run across repeated calls with the same state and args", () => {
+    const combiner = vi.fn((points: readonly number[], axisId: string) => ({
+      axisId,
+      total: points.reduce((a, b) => a + b, 0),
+    }));
+    const selector = createSelector(
+      [(s: TestState) => s.data.points, (_s: TestState, axisId: string) => axisId],
+      combiner,
+    );
+
+    const state = makeState();
+    const first = selector(state, "x");
+    const second = selector(state, "x");
+
+    expect(combiner).toHaveBeenCalledTimes(1);
+    expect(second).toBe(first);
+  });
+
+  it("keeps separate cache nodes per argument combination (SameValueZero keys)", () => {
+    const combiner = vi.fn((points: readonly number[], axisId: string | number) => ({
+      axisId,
+      count: points.length,
+    }));
+    const selector = createSelector(
+      [(s: TestState) => s.data.points, (_s: TestState, axisId: string | number) => axisId],
+      combiner,
+    );
+
+    const state = makeState();
+    const zeroNumber = selector(state, 0);
+    const zeroString = selector(state, "0");
+
+    // `0` and `"0"` are distinct axis ids — distinct nodes.
+    expect(combiner).toHaveBeenCalledTimes(2);
+    expect(selector(state, 0)).toBe(zeroNumber);
+    expect(selector(state, "0")).toBe(zeroString);
+    expect(combiner).toHaveBeenCalledTimes(2);
+  });
+
+  it("isolates caches per store: alternating stores never thrash each other", () => {
+    const combiner = vi.fn((points: readonly number[]) => points.length);
+    const selector = createSelector([(s: TestState) => s.data.points], combiner);
+
+    const a = makeState();
+    const b = makeState();
+    selector(a);
+    selector(b);
+    selector(a);
+    selector(b);
+
+    expect(combiner).toHaveBeenCalledTimes(2);
+  });
+
+  it("recomputes when an input reference changes, and only then", () => {
+    const combiner = vi.fn((domain: readonly number[]) => [...domain]);
+    const selector = createSelector([(s: TestState) => s.axis.domain], combiner);
+
+    const state = makeState();
+    const first = selector(state);
+    expect(combiner).toHaveBeenCalledTimes(1);
+
+    // Unrelated branch replaced: input reference unchanged → cache hit.
+    state.unrelated = { counter: 1 };
+    expect(selector(state)).toBe(first);
+    expect(combiner).toHaveBeenCalledTimes(1);
+
+    // Input path replaced (slice immutability contract) → recompute.
+    state.axis = { domain: [0, 2] };
+    const second = selector(state);
+    expect(combiner).toHaveBeenCalledTimes(2);
+    expect(second).toEqual([0, 2]);
+    expect(second).not.toBe(first);
+  });
+
+  it("resultEqualityCheck preserves the previous reference on value-equal recomputes", () => {
+    const combiner = vi.fn((points: readonly number[]) => points.map((p) => p * 2));
+    const selector = createSelector([(s: TestState) => s.data.points], combiner, {
+      resultEqualityCheck: (prev, next) =>
+        prev.length === next.length && prev.every((v, i) => v === next[i]),
+    });
+
+    const state = makeState();
+    const first = selector(state);
+
+    // New input reference, same values → combiner runs, previous reference survives.
+    state.data = { points: [1, 2, 3] };
+    expect(selector(state)).toBe(first);
+    expect(combiner).toHaveBeenCalledTimes(2);
+
+    // And the value-equal result is cached: the next call is a pure cache hit.
+    expect(selector(state)).toBe(first);
+    expect(combiner).toHaveBeenCalledTimes(2);
+
+    // Genuinely different values → new reference.
+    state.data = { points: [4, 5] };
+    expect(selector(state)).toEqual([8, 10]);
+    expect(selector(state)).not.toBe(first);
+  });
+
+  it("propagates reactively through input reads, including after cache hits", () => {
+    const [state, setState] = createStore<TestState>(makeState());
+    const combiner = vi.fn((domain: readonly number[]) => domain[1]);
+    const selector = createSelector([(s: TestState) => s.axis.domain], combiner);
+
+    const { result: upper } = renderHook(() => createMemo(() => selector(state)));
+    flush();
+    expect(upper()).toBe(1);
+
+    // A cache-hit evaluation in between must not drop the input subscription.
+    expect(selector(state)).toBe(1);
+
+    setState((s) => {
+      s.axis = { domain: [0, 5] };
+    });
+    flush();
+    expect(upper()).toBe(5);
+    expect(combiner).toHaveBeenCalledTimes(2);
+  });
+
+  it("runs the combiner untracked: state read only inside a combiner does not subscribe", () => {
+    const [state, setState] = createStore<TestState>(makeState());
+    // Contract violation on purpose: the combiner reads state directly.
+    const impure = createSelector([(s: TestState) => s.axis.domain], () => state.unrelated.counter);
+
+    const { result } = renderHook(() => createMemo(() => impure(state)));
+    flush();
+    expect(result()).toBe(0);
+
+    setState((s) => {
+      s.unrelated = { counter: 7 };
+    });
+    flush();
+    // No input reference changed and the combiner's read was untracked:
+    // the memo must NOT have re-run. This documents the purity contract.
+    expect(result()).toBe(0);
+  });
+});

package/test/state/hooks.spec.tsx

@@ -14,7 +14,7 @@
 // asserted after `flush()` (Solid batches writes on microtasks).
 import { describe, expect, it } from "vitest";
 import { flush } from "solid-js";
-import { renderHook } from "../helper/render";
+import { renderHook } from "@solidjs/testing-library";
 import { useAppSelector, useAppStore } from "../../src/state/hooks";
 import { RechartsStoreProvider } from "../../src/state/RechartsStoreProvider";
 

package/test/state/registerInStore.spec.tsx

@@ -0,0 +1,101 @@
+// Unit spec for the register-while-mounted idiom (src/state/registerInStore.ts).
+// No upstream counterpart — upstream hand-rolls two useLayoutEffects per site;
+// this module concentrates the Solid-port equivalent, so this spec pins the
+// contract every graphical item / axis / reference / tooltip / legend relies on.
+//
+// The interface is the test surface: (compute, {add, replace, remove}). These
+// exercise it with spy handlers and a signal-driven compute — the same seam the
+// 17 call sites cross. The global diagnostics guard in test/setup.ts additionally
+// fails any of these on an unexpected reactive-graph diagnostic (e.g. a
+// STRICT_READ_UNTRACKED, which would fire if the apply phase read a signal), so
+// the add/replace cases double as a check that the two-arg createEffect shape
+// keeps reactive reads in the compute phase only.
+//
+// Not asserted here: that removal runs owner-free (unregisterOnCleanup's
+// runWithOwner(null), guarding SIGNAL_WRITE_IN_OWNED_SCOPE — a store write while a
+// live parent disposes an owned child). That property IS exercised, just not in
+// isolation: every graphical-item / axis component mount+unmount in the component
+// suite writes to the real store on disposal, and the e2e suite covers real
+// router/subtree teardown. A standalone unit attempt writes to a synthetic store
+// during a disposal flush, which trips an unrelated test-harness scheduler
+// artifact ("fn is not a function") rather than the diagnostic — so it would test
+// the harness, not the contract.
+import { describe, expect, it, vi } from "vitest";
+import { createSignal, flush } from "solid-js";
+import { renderHook } from "@solidjs/testing-library";
+import { registerInStore } from "../../src/state/registerInStore";
+
+const makeHandlers = () => ({ add: vi.fn(), replace: vi.fn(), remove: vi.fn() });
+
+describe("registerInStore", () => {
+  it("calls add once on first registration", () => {
+    const handlers = makeHandlers();
+    renderHook(() => registerInStore(() => ({ id: "a" }), handlers));
+    flush();
+
+    expect(handlers.add).toHaveBeenCalledTimes(1);
+    expect(handlers.add).toHaveBeenCalledWith({ id: "a" });
+    expect(handlers.replace).not.toHaveBeenCalled();
+    expect(handlers.remove).not.toHaveBeenCalled();
+  });
+
+  it("calls replace(prev, next) when the computed settings change", () => {
+    const handlers = makeHandlers();
+    const { result: setN } = renderHook(() => {
+      const [n, setN] = createSignal(1);
+      registerInStore(() => ({ id: "a", n: n() }), handlers);
+      return setN;
+    });
+    flush();
+    expect(handlers.add).toHaveBeenCalledWith({ id: "a", n: 1 });
+
+    setN(2);
+    flush();
+
+    expect(handlers.replace).toHaveBeenCalledTimes(1);
+    expect(handlers.replace).toHaveBeenCalledWith({ id: "a", n: 1 }, { id: "a", n: 2 });
+    // add fires exactly once, ever.
+    expect(handlers.add).toHaveBeenCalledTimes(1);
+  });
+
+  it("skips the tick when compute returns undefined and preserves prev", () => {
+    const handlers = makeHandlers();
+    const { result: setOn } = renderHook(() => {
+      const [on, setOn] = createSignal(true);
+      registerInStore(() => (on() ? { id: "a" } : undefined), handlers);
+      return setOn;
+    });
+    flush();
+    expect(handlers.add).toHaveBeenCalledTimes(1);
+
+    setOn(false); // compute → undefined: no write, prev untouched
+    flush();
+    expect(handlers.replace).not.toHaveBeenCalled();
+    expect(handlers.remove).not.toHaveBeenCalled();
+
+    setOn(true); // valid again: prev survived, so this is a replace — not a second add
+    flush();
+    expect(handlers.add).toHaveBeenCalledTimes(1);
+    expect(handlers.replace).toHaveBeenCalledTimes(1);
+  });
+
+  it("calls remove(prev) on unmount", () => {
+    const handlers = makeHandlers();
+    const { cleanup } = renderHook(() => registerInStore(() => ({ id: "a" }), handlers));
+    flush();
+
+    cleanup();
+    expect(handlers.remove).toHaveBeenCalledTimes(1);
+    expect(handlers.remove).toHaveBeenCalledWith({ id: "a" });
+  });
+
+  it("does not call remove on unmount when it never registered", () => {
+    const handlers = makeHandlers();
+    const { cleanup } = renderHook(() => registerInStore(() => undefined, handlers));
+    flush();
+
+    cleanup();
+    expect(handlers.add).not.toHaveBeenCalled();
+    expect(handlers.remove).not.toHaveBeenCalled();
+  });
+});

package/test/state/selectors/axisSelectors.spec.tsx

@@ -40,7 +40,7 @@ import { PageData, misbehavedData } from "../../_data";
 import { createSelectorTestCase } from "../../helper/createSelectorTestCase";
 import { expectXAxisTicks } from "../../helper/expectAxisTicks";
 import { expectLastCalledWithScale } from "../../helper/expectScale";
-import { render } from "../../helper/render";
+import { render } from "@solidjs/testing-library";
 import { useAppStore } from "../../../src/state/hooks";
 import {
   shouldReturnFromInitialState,

package/test/state/selectors/combiners/combineConfiguredScale.spec.ts

@@ -1,4 +1,4 @@
-import { scaleLinear } from "victory-vendor/d3-scale";
+import { scaleLinear } from "d3-scale";
 import { describe, expect, it } from "vitest";
 import { assertNotNull } from "../../../helper/assertNotNull";
 import { AxisRange } from "../../../../src/state/selectors/axisSelectors";

package/test/state/selectors/combiners/combineRealScaleType.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { scaleLog } from "victory-vendor/d3-scale";
+import { scaleLog } from "d3-scale";
 import { BaseCartesianAxis } from "../../../../src/state/cartesianAxisSlice";
 import { combineRealScaleType } from "../../../../src/state/selectors/combiners/combineRealScaleType";
 

package/test/state/selectors/dataSelectors.spec.tsx

@@ -10,7 +10,7 @@ import {
   useAppSelectorWithStableTest,
 } from "../../helper/selectorTestHelpers";
 import { expectLastCalledWith } from "../../helper/expectLastCalledWith";
-import { render } from "../../helper/render";
+import { render } from "@solidjs/testing-library";
 
 // Ported from recharts 3.8.1 test/state/selectors/dataSelectors.spec.tsx.
 

package/test/state/selectors/legendSelectors.spec.tsx

@@ -14,7 +14,7 @@ import {
   useAppSelectorWithStableTest,
 } from "../../helper/selectorTestHelpers";
 import { mockGetBoundingClientRect } from "../../helper/mockGetBoundingClientRect";
-import { render } from "../../helper/render";
+import { render } from "@solidjs/testing-library";
 
 // Ported from recharts 3.8.1 test/state/selectors/legendSelectors.spec.tsx.
 

package/test/state/selectors/radarSelectors.spec.tsx

@@ -7,7 +7,7 @@
 // asserts the selector VALUE before/after the click (render-count assertions dropped).
 import { createEffect, createSignal, flush } from "solid-js";
 import { describe, expect, it, vi } from "vitest";
-import { fireEvent, render } from "../../helper/render";
+import { fireEvent, render } from "@solidjs/testing-library";
 import { useAppSelectorWithStableTest } from "../../helper/selectorTestHelpers";
 import { RechartsRootState } from "../../../src/state/store";
 import {

package/test/state/selectors/selectActiveTooltipIndex.spec.tsx

@@ -1,6 +1,6 @@
 import { beforeEach, describe, it } from "vitest";
 import { flush } from "solid-js";
-import { fireEvent } from "../../helper/render";
+import { fireEvent } from "@solidjs/testing-library";
 import { createSelectorTestCase } from "../../helper/createSelectorTestCase";
 import { RadialBar, RadialBarChart, Tooltip } from "../../../src";
 import { PageData } from "../../_data";

package/test/state/selectors/selectDisplayedData.spec.tsx

@@ -16,7 +16,7 @@ import {
   useAppSelectorWithStableTest,
 } from "../../helper/selectorTestHelpers";
 import { expectLastCalledWith } from "../../helper/expectLastCalledWith";
-import { render } from "../../helper/render";
+import { render } from "@solidjs/testing-library";
 
 const data1 = [
   { label: "Iter: 0", x: 211, y: 481, z: 1798 },

package/test/state/selectors/selectStackGroups.spec.tsx

@@ -12,7 +12,7 @@
 import { createSignal, flush } from "solid-js";
 import type { JSX } from "@solidjs/web";
 import { describe, expect, it } from "vitest";
-import { fireEvent } from "../../helper/render";
+import { fireEvent } from "@solidjs/testing-library";
 import type { RechartsRootState } from "../../../src/state/store";
 import { selectStackGroups } from "../../../src/state/selectors/axisSelectors";
 import {