solid-recharts 0.2.1 → 1.0.0

package/test/state/externalEventsMiddleware.spec.ts

@@ -1,178 +0,0 @@
-import { flush } from "solid-js";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { CategoricalChartFunc } from "../../src/chart/types";
-import { dispatchExternalEvent } from "../../src/state/externalEventsMiddleware";
-import { createRechartsStore } from "../../src/state/store";
-
-function createMockEvent(type: string): MouseEvent {
-  const event = new MouseEvent(type);
-  Object.defineProperty(event, "currentTarget", {
-    configurable: true,
-    value: document.createElement("div"),
-  });
-  return event;
-}
-
-describe("externalEventsMiddleware", () => {
-  let store: ReturnType<typeof createRechartsStore>;
-  let mockHandler: ReturnType<typeof vi.fn<CategoricalChartFunc<MouseEvent>>>;
-  let mockEvent: MouseEvent;
-
-  beforeEach(() => {
-    store = createRechartsStore();
-    mockHandler = vi.fn<CategoricalChartFunc<MouseEvent>>();
-    mockEvent = createMockEvent("mousemove");
-    vi.clearAllTimers();
-  });
-
-  it("should not call handler when handler is undefined", () => {
-    dispatchExternalEvent(store, {
-      reactEvent: mockEvent,
-      handler: undefined,
-    });
-
-    flush();
-    vi.runAllTimers();
-
-    expect(mockHandler).not.toHaveBeenCalled();
-  });
-
-  it("should call handler with state and event after requestAnimationFrame triggers", () => {
-    dispatchExternalEvent(store, {
-      reactEvent: mockEvent,
-      handler: mockHandler,
-    });
-
-    expect(mockHandler).toHaveBeenCalledTimes(0);
-    expect(vi.getTimerCount()).toBeGreaterThan(0);
-
-    flush();
-    vi.runAllTimers();
-
-    expect(vi.getTimerCount()).toBe(0);
-    expect(mockHandler).toHaveBeenCalledTimes(1);
-    expect(mockHandler).toHaveBeenCalledWith(
-      expect.objectContaining({
-        activeCoordinate: undefined,
-        activeDataKey: undefined,
-        activeIndex: null,
-        activeLabel: undefined,
-        activeTooltipIndex: null,
-        isTooltipActive: false,
-      }),
-      expect.objectContaining({
-        type: mockEvent.type,
-      }),
-    );
-  });
-
-  it("should not need to persist the event for Solid users", () => {
-    dispatchExternalEvent(store, {
-      reactEvent: mockEvent,
-      handler: mockHandler,
-    });
-
-    expect(mockHandler).toHaveBeenCalledTimes(0);
-    expect(vi.getTimerCount()).toBeGreaterThan(0);
-  });
-
-  it("should cancel previous animation frame when dispatched multiple times with same event type", () => {
-    const firstEvent = createMockEvent("touchmove");
-    const secondEvent = createMockEvent("touchmove");
-
-    dispatchExternalEvent(store, {
-      reactEvent: firstEvent,
-      handler: mockHandler,
-    });
-
-    dispatchExternalEvent(store, {
-      reactEvent: secondEvent,
-      handler: mockHandler,
-    });
-
-    flush();
-    vi.runAllTimers();
-
-    expect(mockHandler).toHaveBeenCalledTimes(1);
-  });
-
-  it("should NOT cancel animation frames for different event types", () => {
-    const touchEvent = createMockEvent("touchmove");
-    const mouseMoveEvent = createMockEvent("mousemove");
-    const handler1 = vi.fn<CategoricalChartFunc<MouseEvent>>();
-    const handler2 = vi.fn<CategoricalChartFunc<MouseEvent>>();
-
-    dispatchExternalEvent(store, {
-      reactEvent: touchEvent,
-      handler: handler1,
-    });
-
-    dispatchExternalEvent(store, {
-      reactEvent: mouseMoveEvent,
-      handler: handler2,
-    });
-
-    flush();
-    vi.runAllTimers();
-
-    expect(handler1).toHaveBeenCalledTimes(1);
-    expect(handler2).toHaveBeenCalledTimes(1);
-  });
-
-  it("should handle multiple handlers with different events", () => {
-    const handler1 = vi.fn<CategoricalChartFunc<MouseEvent>>();
-    const handler2 = vi.fn<CategoricalChartFunc<MouseEvent>>();
-    const event1 = createMockEvent("touchmove");
-    const event2 = createMockEvent("mousemove");
-
-    dispatchExternalEvent(store, {
-      reactEvent: event1,
-      handler: handler1,
-    });
-
-    dispatchExternalEvent(store, {
-      reactEvent: event2,
-      handler: handler2,
-    });
-
-    flush();
-    vi.runAllTimers();
-
-    expect(handler1).toHaveBeenCalledTimes(1);
-    expect(handler2).toHaveBeenCalledTimes(1);
-  });
-
-  it("should have access to currentTarget in the async handler even if it is nullified on the original event", () => {
-    let currentTarget: HTMLElement | null = document.createElement("div");
-    const spy = vi.fn();
-    const eventWithCurrentTarget = new MouseEvent("mousemove");
-    Object.defineProperty(eventWithCurrentTarget, "currentTarget", {
-      configurable: true,
-      get() {
-        return currentTarget;
-      },
-    });
-    Object.defineProperty(eventWithCurrentTarget, "preventDefault", {
-      configurable: true,
-      value: spy,
-    });
-
-    dispatchExternalEvent(store, {
-      reactEvent: eventWithCurrentTarget,
-      handler: mockHandler,
-    });
-
-    currentTarget = null;
-
-    flush();
-    vi.runAllTimers();
-
-    expect(mockHandler).toHaveBeenCalledTimes(1);
-    const eventPassedToHandler = mockHandler.mock.calls[0]?.[1];
-    expect(eventPassedToHandler?.currentTarget).not.toBeNull();
-    expect(eventPassedToHandler?.currentTarget).toBeInstanceOf(HTMLDivElement);
-    expect(spy).toHaveBeenCalledTimes(0);
-    eventPassedToHandler?.preventDefault();
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-});

package/test/state/graphicalItemsSlice.spec.ts

@@ -1,92 +0,0 @@
-// Tier-B port of recharts 3.8.1 test/state/graphicalItemsSlice.spec.ts (commit 7a23854).
-//
-// Deviation: recharts drives the slice through the Redux API
-// (`store.dispatch(addCartesianGraphicalItem(item))` + `store.getState()`). Our
-// Solid-native store has no dispatch — actions are called directly
-// (`store.actions.graphicalItems.addCartesianGraphicalItem(item)`) and state is
-// read via selectors against `store.state`. Expectations are unchanged.
-import { describe, expect, it } from "vitest";
-import { flush } from "solid-js";
-import { createRechartsStore } from "../../src/state/store";
-import { PageData } from "../_data";
-import { selectUnfilteredCartesianItems } from "../../src/state/selectors/axisSelectors";
-import { BarSettings } from "../../src/state/types/BarSettings";
-import { LineSettings } from "../../src/state/types/LineSettings";
-import { AreaSettings } from "../../src/state/types/AreaSettings";
-
-describe("graphicalItemsSlice", () => {
-  const item1: BarSettings = {
-    maxBarSize: 0,
-    minPointSize: 0,
-    id: "my-bar",
-    isPanorama: false,
-    type: "bar",
-    stackId: undefined,
-    dataKey: undefined,
-    data: PageData,
-    xAxisId: "x",
-    yAxisId: "y",
-    zAxisId: 0,
-    hide: false,
-    barSize: undefined,
-    hasCustomShape: false,
-  };
-
-  const item2: LineSettings = {
-    id: "my-line",
-    isPanorama: false,
-    type: "line",
-    dataKey: undefined,
-    data: PageData,
-    xAxisId: "x",
-    yAxisId: "y",
-    zAxisId: 0,
-    hide: false,
-  };
-
-  const item3: AreaSettings = {
-    baseValue: undefined,
-    connectNulls: false,
-    id: "my-area",
-    isPanorama: false,
-    type: "area",
-    stackId: undefined,
-    dataKey: "a",
-    data: PageData,
-    xAxisId: "x",
-    yAxisId: "y",
-    zAxisId: 0,
-    hide: false,
-    barSize: undefined,
-  };
-
-  it("should add and remove graphical items from state", () => {
-    const store = createRechartsStore();
-    expect(selectUnfilteredCartesianItems(store.state)).toHaveLength(0);
-
-    store.actions.graphicalItems.addCartesianGraphicalItem(item1);
-    flush();
-    expect(selectUnfilteredCartesianItems(store.state)).toEqual([item1]);
-
-    store.actions.graphicalItems.removeCartesianGraphicalItem(item1);
-    flush();
-    expect(selectUnfilteredCartesianItems(store.state)).toHaveLength(0);
-  });
-
-  it("should replace graphical items in state and keep the order", () => {
-    const store = createRechartsStore();
-    expect(selectUnfilteredCartesianItems(store.state)).toHaveLength(0);
-
-    store.actions.graphicalItems.addCartesianGraphicalItem(item1);
-    store.actions.graphicalItems.addCartesianGraphicalItem(item2);
-    flush();
-    expect(selectUnfilteredCartesianItems(store.state)).toEqual([item1, item2]);
-
-    // Replace item1 with item3
-    store.actions.graphicalItems.replaceCartesianGraphicalItem({ prev: item1, next: item3 });
-    flush();
-
-    // item3 is now in place of item1, and item2 remains on the second position
-    expect(selectUnfilteredCartesianItems(store.state)).toEqual([item3, item2]);
-  });
-});

package/test/state/hooks.spec.tsx

@@ -1,68 +0,0 @@
-// Tier B port of recharts 3.8.1 test/state/hooks.spec.tsx.
-//
-// The recharts spec tests the react-redux binding and Redux store mechanics:
-// `useAppSelector` via useSyncExternalStore, `useAppDispatch`/`dispatch(action)`,
-// re-render-on-dispatch, and `store.subscribe(spy)`. None of that exists in the
-// Solid-native rewrite (no Redux store, no dispatch, no re-render). This spec is
-// re-expressed against the equivalent Solid-native contract, preserving the
-// behavioral guarantees recharts cared about:
-//   - outside a chart, `useAppSelector` yields `undefined` and never throws;
-//   - inside the provider, it yields the live state;
-//   - it updates reactively when an action mutates the store;
-//   - the store's actions are reachable inside the provider.
-// The provider is supplied via renderHook's `wrapper`; reactive reads are
-// asserted after `flush()` (Solid batches writes on microtasks).
-import { describe, expect, it } from "vitest";
-import { flush } from "solid-js";
-import { renderHook } from "@solidjs/testing-library";
-import { useAppSelector, useAppStore } from "../../src/state/hooks";
-import { RechartsStoreProvider } from "../../src/state/RechartsStoreProvider";
-
-describe("useAppSelector", () => {
-  it("should return undefined when used outside of the store context", () => {
-    const { result } = renderHook(() => useAppSelector((s) => s));
-    expect(result()).toBeUndefined();
-  });
-
-  it("should not throw an error when used outside of the store context", () => {
-    expect(() => renderHook(() => useAppSelector((s) => s))).not.toThrow();
-  });
-
-  it("should return state when inside the store provider", () => {
-    const { result } = renderHook(() => useAppSelector((s) => s), {
-      wrapper: RechartsStoreProvider,
-    });
-    expect(result()).not.toBeUndefined();
-  });
-
-  it("should update after an action changes the state", () => {
-    const { result } = renderHook(
-      () => {
-        const store = useAppStore();
-        const chartData = useAppSelector((s) => s.chartData.chartData);
-        return { store, chartData };
-      },
-      { wrapper: RechartsStoreProvider },
-    );
-
-    expect(result.chartData()).toBeUndefined();
-
-    result.store?.actions.chartData.setChartData([]);
-    flush();
-
-    expect(result.chartData()).toEqual([]);
-  });
-});
-
-describe("useAppStore", () => {
-  it("should return undefined and not throw when used outside the store context", () => {
-    const { result } = renderHook(() => useAppStore());
-    expect(result).toBeUndefined();
-  });
-
-  it("should expose slice actions when inside the store provider", () => {
-    const { result } = renderHook(() => useAppStore(), { wrapper: RechartsStoreProvider });
-    expect(result).not.toBeUndefined();
-    expect(typeof result?.actions.chartData.setChartData).toBe("function");
-  });
-});

package/test/state/legendSlice.spec.ts

@@ -1,44 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { flush } from "solid-js";
-import { createRechartsStore } from "../../src/state/store";
-import type { LegendPayloadEntry } from "../../src/state/legendSlice";
-
-/*
- * Ported from recharts 3.8.1 test/state/legendSlice.spec.ts, adapted to the
- * Solid-native store (store.state / store.actions, flush(); no Redux dispatch) and
- * this port's legend-payload shape deviation: recharts stores a flat
- * `ReadonlyArray<LegendPayload>` and matches for removal by object reference; this
- * port stores `ReadonlyArray<LegendPayloadEntry>` (each entry has a stable `id`
- * holding its items) and matches for removal by `id`. The add/remove behaviour
- * recharts cares about is preserved.
- */
-
-describe("legendSlice", () => {
-  it("should add and remove legend payload from state", () => {
-    const store = createRechartsStore();
-    expect(store.state.legend.payload).toHaveLength(0);
-
-    const entry1: LegendPayloadEntry = { id: "a", items: [{ dataKey: "key", value: "value" }] };
-    const entry2: LegendPayloadEntry = { id: "b", items: [{ dataKey: "key", value: "value" }] };
-
-    store.actions.legend.addLegendPayload(entry1);
-    flush();
-    expect(store.state.legend.payload).toHaveLength(1);
-
-    store.actions.legend.addLegendPayload(entry2);
-    flush();
-    expect(store.state.legend.payload).toHaveLength(2);
-
-    store.actions.legend.removeLegendPayload(entry1);
-    flush();
-    expect(store.state.legend.payload).toHaveLength(1);
-
-    store.actions.legend.removeLegendPayload(entry2);
-    flush();
-    expect(store.state.legend.payload).toHaveLength(0);
-
-    store.actions.legend.removeLegendPayload(entry1);
-    flush();
-    expect(store.state.legend.payload).toHaveLength(0);
-  });
-});

package/test/state/mouseEventsMiddleware.spec.ts

@@ -1,75 +0,0 @@
-import { flush } from "solid-js";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { HTMLMousePointer } from "../../src/util/types";
-import { createRechartsStore } from "../../src/state/store";
-import { dispatchMouseClick, dispatchMouseMove } from "../../src/state/mouseEventsMiddleware";
-import { getMockDomRect } from "../helper/mockGetBoundingClientRect";
-
-function createMockMousePointer(x: number, y: number): HTMLMousePointer {
-  return {
-    clientX: x,
-    clientY: y,
-    currentTarget: {
-      getBoundingClientRect: () => getMockDomRect({ width: 500, height: 300 }),
-      offsetWidth: 500,
-      offsetHeight: 300,
-    },
-  };
-}
-
-describe("mouseClickMiddleware", () => {
-  let store: ReturnType<typeof createRechartsStore>;
-
-  beforeEach(() => {
-    store = createRechartsStore();
-  });
-
-  it("should run immediately without requestAnimationFrame", () => {
-    const mockMousePointer = createMockMousePointer(100, 100);
-    expect(vi.getTimerCount()).toBe(0);
-
-    dispatchMouseClick(store, mockMousePointer);
-
-    expect(vi.getTimerCount()).toBe(0);
-  });
-
-  it("should handle multiple clicks without canceling each other", () => {
-    const click1 = createMockMousePointer(50, 50);
-    const click2 = createMockMousePointer(100, 100);
-    const click3 = createMockMousePointer(150, 150);
-
-    dispatchMouseClick(store, click1);
-    dispatchMouseClick(store, click2);
-    dispatchMouseClick(store, click3);
-
-    expect(vi.getTimerCount()).toBe(0);
-  });
-});
-
-describe("mouseMoveMiddleware", () => {
-  let store: ReturnType<typeof createRechartsStore>;
-
-  beforeEach(() => {
-    store = createRechartsStore();
-  });
-
-  it("should debounce rapid mousemove events using requestAnimationFrame", () => {
-    const move1 = createMockMousePointer(50, 50);
-    const move2 = createMockMousePointer(100, 100);
-    const move3 = createMockMousePointer(150, 150);
-
-    dispatchMouseMove(store, move1);
-    expect(vi.getTimerCount()).toBe(1);
-
-    dispatchMouseMove(store, move2);
-    expect(vi.getTimerCount()).toBe(1);
-
-    dispatchMouseMove(store, move3);
-    expect(vi.getTimerCount()).toBe(1);
-
-    flush();
-    vi.runOnlyPendingTimers();
-
-    expect(vi.getTimerCount()).toBe(0);
-  });
-});

package/test/state/optionsSlice.spec.ts

@@ -1,19 +0,0 @@
-// Ported from recharts 3.8.1 test/state/optionsSlice.spec.ts (tests the pure
-// `arrayTooltipSearcher` helper). Assertions byte-identical.
-import { describe, it, expect } from "vitest";
-import { arrayTooltipSearcher } from "../../src/state/optionsSlice";
-
-describe("arrayTooltipSearcher", () => {
-  it("should return undefined when called with empty array or empty index", () => {
-    expect(arrayTooltipSearcher([], "0")).toBeUndefined();
-    expect(arrayTooltipSearcher(undefined, "0")).toBeUndefined();
-    expect(arrayTooltipSearcher([1, 2, 3], "")).toBeUndefined();
-    // @ts-expect-error typescript is correct here, but we are testing runtime behavior with invalid input
-    expect(arrayTooltipSearcher([1, 2, 3], undefined)).toBeUndefined();
-    expect(arrayTooltipSearcher([1, 2, 3], "NaN")).toBeUndefined();
-  });
-
-  it("should return data from an index when given a valid number", () => {
-    expect(arrayTooltipSearcher([1, 2, 3], "0")).toBe(1);
-  });
-});

package/test/state/referenceElementsSlice.spec.ts

@@ -1,84 +0,0 @@
-// Tier B (state-internal): ported from recharts' referenceElementsSlice.spec.ts,
-// adapted to the Solid-native store (store.state / store.actions, no dispatch) and
-// the `id`-based identity deviation (recharts matches by object reference; Solid
-// store proxies break that, so each settings object carries a stable `id`).
-import { describe, it, expect } from "vitest";
-import { flush } from "solid-js";
-import type {
-  ReferenceAreaSettings,
-  ReferenceDotSettings,
-  ReferenceLineSettings,
-} from "../../src/state/referenceElementsSlice";
-import { createRechartsStore } from "../../src/state/store";
-
-describe("referenceElementsSlice", () => {
-  it("should add and remove a reference dot", () => {
-    const store = createRechartsStore();
-    expect(store.state.referenceElements.dots).toEqual([]);
-
-    const dot: ReferenceDotSettings = {
-      id: "dot-1",
-      ifOverflow: "visible",
-      r: 1,
-      x: 2,
-      xAxisId: 3,
-      y: "category 4",
-      yAxisId: 5,
-    };
-
-    store.actions.referenceElements.addDot(dot);
-    flush();
-    expect(store.state.referenceElements.dots).toEqual([dot]);
-
-    store.actions.referenceElements.removeDot(dot);
-    flush();
-    expect(store.state.referenceElements.dots).toEqual([]);
-  });
-
-  it("should add and remove a reference area", () => {
-    const store = createRechartsStore();
-    expect(store.state.referenceElements.areas).toEqual([]);
-
-    const area: ReferenceAreaSettings = {
-      id: "area-1",
-      ifOverflow: "visible",
-      x1: 1,
-      x2: 2,
-      xAxisId: 3,
-      y1: "category 4",
-      y2: "category 5",
-      yAxisId: 6,
-    };
-
-    store.actions.referenceElements.addArea(area);
-    flush();
-    expect(store.state.referenceElements.areas).toEqual([area]);
-
-    store.actions.referenceElements.removeArea(area);
-    flush();
-    expect(store.state.referenceElements.areas).toEqual([]);
-  });
-
-  it("should add and remove a reference line", () => {
-    const store = createRechartsStore();
-    expect(store.state.referenceElements.lines).toEqual([]);
-
-    const line: ReferenceLineSettings = {
-      id: "line-1",
-      ifOverflow: "visible",
-      x: 1,
-      xAxisId: 2,
-      y: "category 3",
-      yAxisId: 4,
-      segment: undefined,
-    };
-
-    store.actions.referenceElements.addLine(line);
-    flush();
-    expect(store.state.referenceElements.lines).toEqual([line]);
-
-    store.actions.referenceElements.removeLine(line);
-    flush();
-    expect(store.state.referenceElements.lines).toEqual([]);
-  });
-});

package/test/state/registerInStore.spec.tsx

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