solid-recharts 0.2.0 → 0.2.1

package/src/util/ChartUtils.ts

@@ -15,16 +15,8 @@ import {
   stackOffsetSilhouette,
   stackOffsetWiggle,
   stackOrderNone,
-} from "victory-vendor/d3-shape";
-import {
-  findEntryInArray,
-  isNan,
-  isNotNil,
-  isNullish,
-  isNumber,
-  isNumOrStr,
-  mathSign,
-} from "./DataUtils";
+} from "d3-shape";
+import { isNan, isNotNil, isNullish, isNumber, isNumOrStr, mathSign } from "./DataUtils";
 import { getSliced } from "./getSliced";
 import { isWellBehavedNumber } from "./isWellBehavedNumber";
 import type {
@@ -276,6 +268,32 @@ export const truncateByDomain = <T>(
   return result;
 };
 
+// Value→tick lookup cache, keyed on the ticks array reference. getCateCoordinateOfLine
+// is called once per data point; a linear findEntryInArray scan there is O(points²)
+// across a full series when allowDuplicatedCategory=false (ticks.length ≈ points).
+// The axis-ticks selector memoizes the ticks array, so this map is built once per
+// render and reused for every point lookup, making it O(points). First value wins,
+// mirroring Array.find.
+const tickByValueCache = new WeakMap<ReadonlyArray<TickItem>, Map<unknown, TickItem>>();
+function findTickByValue(ticks: ReadonlyArray<TickItem>, value: unknown): TickItem | undefined {
+  // Map uses SameValueZero and would match NaN, while the upstream Array.find
+  // lookup uses strict equality (NaN !== NaN). Preserve that fallback behavior.
+  if (typeof value === "number" && Number.isNaN(value)) {
+    return undefined;
+  }
+  let map = tickByValueCache.get(ticks);
+  if (map == null) {
+    map = new Map<unknown, TickItem>();
+    for (const tick of ticks) {
+      if (tick != null && !map.has(tick.value)) {
+        map.set(tick.value, tick);
+      }
+    }
+    tickByValueCache.set(ticks, map);
+  }
+  return map.get(value);
+}
+
 export function getCateCoordinateOfLine<T>({
   axis,
   ticks,
@@ -312,7 +330,7 @@ export function getCateCoordinateOfLine<T>({
       const key: string | number = axisDataKey;
       const cellValue = entry[key];
       if (!isNullish(cellValue)) {
-        const matchedTick = ticks ? findEntryInArray(ticks, "value", cellValue) : undefined;
+        const matchedTick = ticks ? findTickByValue(ticks, cellValue) : undefined;
 
         if (matchedTick) {
           return matchedTick.coordinate + bandSize / 2;
@@ -625,35 +643,61 @@ export const getStackedData = (
   offsetType: StackOffsetType,
 ): ReadonlyArray<Series<StackDatum, StackKey>> => {
   const offsetAccessor: OffsetAccessor = STACK_OFFSET_MAP[offsetType] ?? offsetSign;
+  // Track whether any value is a [min, max] tuple during the (unavoidable) value
+  // accessor pass, so the ranged-data fixup below can be skipped entirely for the
+  // common scalar case instead of running a second full series×points scan.
+  let hasRangedValues = false;
   const stack = shapeStack<StackDatum, StackKey>()
     .keys(dataKeys)
-    .value((d, key) => Number(getValueByDataKey(d, key, 0)))
+    .value((d, key) => {
+      const raw = getValueByDataKey(d, key, 0);
+      if (Array.isArray(raw) && raw.length === 2) {
+        hasRangedValues = true;
+      }
+      return Number(raw);
+    })
     .order(stackOrderNone)
     .offset(offsetAccessor);
 
   const result = stack(data);
 
   // Ranged data: when a value is a [min, max] tuple, use it directly (no stacking).
-  result.forEach((s, seriesIndex) => {
-    s.forEach((point, pointIndex) => {
-      const value = getValueByDataKey(data[pointIndex], dataKeys[seriesIndex], 0);
-      if (value != null && Array.isArray(value) && value.length === 2) {
-        const lo: unknown = value[0];
-        const hi: unknown = value[1];
-        if (isNumber(lo) && isNumber(hi)) {
-          point[0] = lo;
-          point[1] = hi;
+  if (hasRangedValues) {
+    result.forEach((s, seriesIndex) => {
+      s.forEach((point, pointIndex) => {
+        const value = getValueByDataKey(data[pointIndex], dataKeys[seriesIndex], 0);
+        if (value != null && Array.isArray(value) && value.length === 2) {
+          const lo: unknown = value[0];
+          const hi: unknown = value[1];
+          if (isNumber(lo) && isNumber(hi)) {
+            point[0] = lo;
+            point[1] = hi;
+          }
         }
-      }
+      });
     });
-  });
+  }
 
   return result;
 };
 
 const getDomainOfSingle = (data: ReadonlyArray<ReadonlyArray<unknown>>): number[] => {
-  const flat = data.flat(2).filter(isNumber);
-  return [Math.min(...flat), Math.max(...flat)];
+  // Reduce loop, not `Math.min(...flat)`: spreading a data-sized array throws a V8
+  // RangeError past ~100k elements. Empty input yields [Infinity, -Infinity],
+  // matching the previous Math.min/Math.max-of-empty behavior.
+  let min = Infinity;
+  let max = -Infinity;
+  for (const value of data.flat(2)) {
+    if (isNumber(value)) {
+      if (value < min) {
+        min = value;
+      }
+      if (value > max) {
+        max = value;
+      }
+    }
+  }
+  return [min, max];
 };
 
 const makeDomainFinite = (domain: NumberDomain): NumberDomain => [

package/src/util/propsAreEqual.ts

@@ -1,16 +1,15 @@
 // Ported from recharts 3.8.1 src/util/propsAreEqual.ts (commit 7a23854).
 //
 // Deviation: recharts imports `shallowEqual` from `react-redux`. A SolidJS port
-// has no react-redux, so we inline an equivalent one-level same-value compare.
-// react-redux's `shallowEqual` is just `Object.is` applied per own-enumerable
-// key (its internal `is` predates and mirrors `Object.is`), so the local
-// version below is behavior-identical — NaN compares equal, +0 and -0 do not.
+// has no react-redux, so it reuses the local equivalent in `./ShallowEqual`
+// (one-level same-value compare — NaN equal, +0 and -0 distinct).
 //
 // NOTE on relevance: recharts uses `propsAreEqual` only as the `React.memo`
 // comparator on Bar/Area/Line/Scatter/Legend/ReportEventSettings/etc. Solid
 // components do not re-render, so when those units are ported this comparator
 // will most likely be dropped or repurposed. The function itself is pure and
 // spec-tested, so we port it now and revisit its call sites in Tier 2.
+import { shallowEqual } from "./ShallowEqual";
 
 const propsToShallowCompare = new Set<string>([
   "axisLine",
@@ -37,35 +36,6 @@ const propsToShallowCompare = new Set<string>([
   "throttledEvents",
 ]);
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
-/**
- * One-level same-value comparison, equivalent to react-redux's `shallowEqual`.
- * Uses `Object.is`, so two NaNs are equal and +0/-0 are not — matching the
- * original.
- */
-function shallowEqual(objA: unknown, objB: unknown): boolean {
-  if (Object.is(objA, objB)) {
-    return true;
-  }
-  if (!isRecord(objA) || !isRecord(objB)) {
-    return false;
-  }
-  const keysA = Object.keys(objA);
-  const keysB = Object.keys(objB);
-  if (keysA.length !== keysB.length) {
-    return false;
-  }
-  for (const key of keysA) {
-    if (!Object.hasOwn(objB, key) || !Object.is(objA[key], objB[key])) {
-      return false;
-    }
-  }
-  return true;
-}
-
 /**
  * When comparing two values, returns true if they are the same value or
  * are both NaN.

package/src/util/stacks/stackTypes.ts

@@ -1,5 +1,5 @@
 // Ported from recharts 3.8.1 src/util/stacks/stackTypes.ts (commit 7a23854).
-import { Series } from "victory-vendor/d3-shape";
+import { Series } from "d3-shape";
 import { StackId } from "../ChartUtils";
 import { DataKey } from "../types";
 import { GraphicalItemId } from "../../state/graphicalItemsSlice";

package/src/util/types.ts

@@ -1,6 +1,6 @@
 import type { JSX } from "@solidjs/web";
 import type { Element } from "solid-js";
-import type * as d3Scales from "victory-vendor/d3-scale";
+import type * as d3Scales from "d3-scale";
 import type { DotProps } from "../shape/Dot";
 import type { ExternalMouseEvents } from "../chart/types";
 

package/test/cartesian/CartesianAxis.spec.tsx

@@ -6,7 +6,7 @@
 // React.cloneElement an already-evaluated element to inject computed x/y — function form
 // covers it).
 import { describe, expect, it } from "vitest";
-import { scaleLinear } from "victory-vendor/d3-scale";
+import { scaleLinear } from "d3-scale";
 import { render } from "@solidjs/testing-library";
 import { CartesianAxis, Surface } from "../../src";
 import type { CartesianTickContentProps, TickItem } from "../../src/util/types";

package/test/cartesian/GraphicalItemClipPath.scale-behavior.spec.tsx

@@ -12,7 +12,7 @@
 // last spy call holds the current points. `p.payload` is `unknown` in our port
 // (recharts erases it via `any`), so a runtime guard reads `name`/`x` — no `as`.
 import { describe, it, expect, beforeEach } from "vitest";
-import { scaleLinear, scalePoint } from "victory-vendor/d3-scale";
+import { scaleLinear, scalePoint } from "d3-scale";
 import { createSignal, flush } from "solid-js";
 import type { JSX } from "@solidjs/web";
 import { fireEvent } from "@solidjs/testing-library";

package/test/cartesian/ReferenceLine/getEndPoints.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { scaleLinear } from "victory-vendor/d3-scale";
+import { scaleLinear } from "d3-scale";
 import { getEndPoints, type ReferenceLineSegment } from "../../../src/cartesian/ReferenceLine";
 import type { CartesianViewBoxRequired } from "../../../src/util/types";
 import {

package/test/cartesian/XAxis/XAxis.timescale.spec.tsx

@@ -2,7 +2,7 @@ import { describe, expect, it, vi } from "vitest";
 import { createEffect } from "solid-js";
 // @ts-expect-error d3-time-format ships no types and victory-vendor does not re-export it.
 import { timeFormat } from "d3-time-format";
-import { scaleTime } from "victory-vendor/d3-scale";
+import { scaleTime } from "d3-scale";
 import { useAppSelector } from "../../../src/state/hooks";
 import { selectRealScaleType } from "../../../src/state/selectors/axisSelectors";
 import { Line, LineChart, XAxis, YAxis } from "../../../src";

package/test/helper/mockAxes.ts

@@ -1,5 +1,5 @@
 // Port of recharts 3.8.1 test/helper/mockAxes.ts (commit 7a23854).
-import { scaleLinear } from "victory-vendor/d3-scale";
+import { scaleLinear } from "d3-scale";
 import {
   BaseAxisWithScale,
   implicitXAxis,

package/test/shape/Curve.spec.tsx

@@ -5,7 +5,7 @@
 import { describe, expect, it, test } from "vitest";
 import { createSignal } from "solid-js";
 import { render, fireEvent } from "@solidjs/testing-library";
-import { curveLinear } from "victory-vendor/d3-shape";
+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/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/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/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";