solid-recharts 0.1.0 → 0.2.1

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

@@ -0,0 +1,136 @@
+// Regression gate for the memoized selector graph (ADR-0002).
+//
+// This is the direct test of the performance win: the expensive
+// applied-values / displayed-data chain must be SHARED (a repeat call returns
+// the identical reference) and must NOT be invalidated by a tooltip/mousemove
+// interaction (the classic recharts hotspot), while STILL invalidating when the
+// underlying chart data actually changes. Reference identity is the observable
+// proxy for "did the O(series×points) combiner re-run".
+import { describe, expect, it } from "vitest";
+import { flush } from "solid-js";
+import { render } from "@solidjs/testing-library";
+import { Line, LineChart, XAxis } from "../../../src";
+import { useAppStore } from "../../../src/state/hooks";
+import { defaultAxisId } from "../../../src/state/cartesianAxisSlice";
+import {
+  selectAllAppliedValues,
+  selectAxisDomain,
+  selectAxisScale,
+  selectCartesianItemsSettings,
+  selectDisplayedData,
+  selectNumericalDomain,
+  selectTicksOfGraphicalItem,
+} from "../../../src/state/selectors/axisSelectors";
+import type { RechartsStore } from "../../../src/state/store";
+
+const data = [
+  { name: "a", uv: 10 },
+  { name: "b", uv: 30 },
+  { name: "c", uv: 20 },
+  { name: "d", uv: 40 },
+];
+
+function renderChartAndCaptureStore(): RechartsStore {
+  let store: RechartsStore | undefined;
+  const Capture = (): null => {
+    store = useAppStore();
+    return null;
+  };
+  render(() => (
+    <LineChart width={200} height={200} data={data}>
+      <XAxis dataKey="name" />
+      <Line dataKey="uv" isAnimationActive={false} />
+      <Capture />
+    </LineChart>
+  ));
+  flush();
+  flush();
+  flush();
+  if (store == null) {
+    throw new Error("store capture failed");
+  }
+  return store;
+}
+
+describe("memoized selector graph", () => {
+  it("shares the applied-values chain: a repeat call returns the identical reference", () => {
+    const store = renderChartAndCaptureStore();
+    const first = selectAllAppliedValues(store.state, "xAxis", defaultAxisId, false);
+    const second = selectAllAppliedValues(store.state, "xAxis", defaultAxisId, false);
+    expect(second).toBe(first);
+    // The intermediate nodes are shared too.
+    expect(selectDisplayedData(store.state, "xAxis", defaultAxisId, false)).toBe(
+      selectDisplayedData(store.state, "xAxis", defaultAxisId, false),
+    );
+    expect(selectCartesianItemsSettings(store.state, "xAxis", defaultAxisId)).toBe(
+      selectCartesianItemsSettings(store.state, "xAxis", defaultAxisId),
+    );
+  });
+
+  it("does NOT invalidate the data chain on a tooltip/mousemove interaction (the fan-out win)", () => {
+    const store = renderChartAndCaptureStore();
+    const before = selectAllAppliedValues(store.state, "xAxis", defaultAxisId, false);
+    const displayedBefore = selectDisplayedData(store.state, "xAxis", defaultAxisId, false);
+
+    // Simulate the per-frame mousemove state write.
+    store.actions.tooltip.setMouseOverAxisIndex({
+      activeIndex: "2",
+      activeDataKey: undefined,
+      activeCoordinate: { x: 50, y: 50 },
+    });
+    flush();
+
+    const after = selectAllAppliedValues(store.state, "xAxis", defaultAxisId, false);
+    const displayedAfter = selectDisplayedData(store.state, "xAxis", defaultAxisId, false);
+    // The expensive chain is untouched by the interaction — same references,
+    // so no combiner re-ran. This is what collapses the ~10× mousemove fan-out.
+    expect(after).toBe(before);
+    expect(displayedAfter).toBe(displayedBefore);
+  });
+
+  it("keeps the full domain→scale→ticks chain stable across a mousemove", () => {
+    const store = renderChartAndCaptureStore();
+    const axes = ["xAxis", "yAxis"] as const;
+    const before = axes.map((axisType) => ({
+      numericalDomain: selectNumericalDomain(store.state, axisType, defaultAxisId, false),
+      axisDomain: selectAxisDomain(store.state, axisType, defaultAxisId, false),
+      scale: selectAxisScale(store.state, axisType, defaultAxisId, false),
+      ticks: selectTicksOfGraphicalItem(store.state, axisType, defaultAxisId, false),
+    }));
+
+    store.actions.tooltip.setMouseOverAxisIndex({
+      activeIndex: "1",
+      activeDataKey: undefined,
+      activeCoordinate: { x: 30, y: 30 },
+    });
+    flush();
+
+    axes.forEach((axisType, i) => {
+      const prev = before[i]!;
+      expect(selectNumericalDomain(store.state, axisType, defaultAxisId, false)).toBe(
+        prev.numericalDomain,
+      );
+      expect(selectAxisDomain(store.state, axisType, defaultAxisId, false)).toBe(prev.axisDomain);
+      expect(selectAxisScale(store.state, axisType, defaultAxisId, false)).toBe(prev.scale);
+      expect(selectTicksOfGraphicalItem(store.state, axisType, defaultAxisId, false)).toBe(
+        prev.ticks,
+      );
+    });
+  });
+
+  it("DOES invalidate when the chart data changes (correctness)", () => {
+    const store = renderChartAndCaptureStore();
+    const before = selectAllAppliedValues(store.state, "xAxis", defaultAxisId, false);
+
+    store.actions.chartData.setChartData([
+      { name: "a", uv: 11 },
+      { name: "b", uv: 31 },
+      { name: "c", uv: 21 },
+    ]);
+    flush();
+
+    const after = selectAllAppliedValues(store.state, "xAxis", defaultAxisId, false);
+    expect(after).not.toBe(before);
+    expect(after.map((v) => v.value)).toEqual(["a", "b", "c"]);
+  });
+});

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

@@ -3,7 +3,7 @@
 // Solid-native store actions; tooltip selector exports live in tooltipSelectors.
 import { createEffect, flush } from "solid-js";
 import { describe, expect, it, test, vi } from "vitest";
-import { render } from "../../helper/render";
+import { render } from "@solidjs/testing-library";
 import { RechartsStoreProvider } from "../../../src/state/RechartsStoreProvider";
 import { createRechartsStore, type RechartsRootState } from "../../../src/state/store";
 import { arrayTooltipSearcher } from "../../../src/state/optionsSlice";

package/test/util/CartesianUtils/CartesianUtils.spec.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { scaleLinear, scaleBand } from "victory-vendor/d3-scale";
+import { scaleLinear, scaleBand } from "d3-scale";
 import { getAngledRectangleWidth, normalizeAngle } from "../../../src/util/CartesianUtils";
 import { rechartsScaleFactory } from "../../../src/util/scale/RechartsScale";
 import { CartesianScaleHelperImpl } from "../../../src/util/scale/CartesianScaleHelper";

package/test/util/ChartUtils/ChartUtils.spec.ts

@@ -1,4 +1,4 @@
-import { scaleBand, scaleLinear, scalePoint } from "victory-vendor/d3-scale";
+import { scaleBand, scaleLinear, scalePoint } from "d3-scale";
 import {
   type AxisPropsNeededForTicksGenerator,
   getBandSizeOfAxis,

package/test/util/ChartUtils/getCateCoordinateOfLine.spec.ts

@@ -79,5 +79,19 @@ describe("getCateCoordinateOfLine", () => {
       });
       expect(actual).toBe(18);
     });
+
+    it("should not match NaN tick values and should fall back to the indexed tick", () => {
+      const actual = getCateCoordinateOfLine({
+        axis: { type: "category", dataKey: "foo", scale: mockScale },
+        bandSize: 4,
+        entry: { foo: NaN },
+        index: 0,
+        ticks: [
+          { coordinate: 8, index: 0, value: "fallback" },
+          { coordinate: 16, index: 1, value: NaN },
+        ],
+      });
+      expect(actual).toBe(10);
+    });
   });
 });

package/test/util/ChartUtils/getStackedData.spec.ts

@@ -1,4 +1,4 @@
-import type { Series, SeriesPoint } from "victory-vendor/d3-shape";
+import type { Series, SeriesPoint } from "d3-shape";
 import { getStackedData, offsetSign } from "../../../src/util/ChartUtils";
 import type { StackOffsetType } from "../../../src/util/types";
 

package/test/util/ChartUtils/truncateByDomain.spec.ts

@@ -1,4 +1,4 @@
-import type { SeriesPoint } from "victory-vendor/d3-shape";
+import type { SeriesPoint } from "d3-shape";
 import { truncateByDomain } from "../../../src/util/ChartUtils";
 
 function createMockSeriesPoint(val: [number, number]): SeriesPoint<Record<number, number>> {

package/test/util/DomUtils.spec.tsx

@@ -1,7 +1,7 @@
 // Ported from recharts 3.8.1 test/util/DomUtils.spec.tsx.
 // Harness changes only: render from the local Solid shim (thunk), no React
 // import. Assertions are byte-identical to recharts.
-import { render } from "../helper/render";
+import { render } from "@solidjs/testing-library";
 import {
   getStringSize,
   clearStringCache,

package/test/util/FunnelUtils.spec.tsx

@@ -6,7 +6,7 @@
 // <Shape>/<Layer> emits `<g class="recharts-layer recharts-active-shape">`, so
 // `toHaveClass('recharts-active-shape')` (substring-class match) still holds.
 import { describe, expect, it } from "vitest";
-import { render } from "../helper/render";
+import { render } from "@solidjs/testing-library";
 import { FunnelTrapezoid, type FunnelTrapezoidProps } from "../../src/util/FunnelUtils";
 import type { Coordinate, TrapezoidViewBox } from "../../src/util/types";
 

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

@@ -1,6 +1,6 @@
 // Ported from recharts 3.8.1 test/util/scale/createCategoricalInverse.spec.ts (commit 7a23854).
 import { describe, it, expect } from "vitest";
-import { scaleLinear } from "victory-vendor/d3-scale";
+import { scaleLinear } from "d3-scale";
 import { bisect, createCategoricalInverse } from "../../../src/util/scale/createCategoricalInverse";
 import { CustomScaleDefinition } from "../../../src/util/scale/CustomScaleDefinition";
 

package/test/util/useElementOffset.spec.tsx

@@ -7,7 +7,7 @@
 // values are byte-identical to recharts.
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { flush } from "solid-js";
-import { renderHook } from "../helper/render";
+import { renderHook } from "@solidjs/testing-library";
 import { useElementOffset } from "../../src/util/useElementOffset";
 import { getMockDomRect } from "../helper/mockGetBoundingClientRect";
 

package/test/util/usePrefersReducedMotion.spec.ts

@@ -3,7 +3,7 @@
 // an Accessor, so the value is read via `result()` where React wrote
 // `result.current`. Assertions/mocks are otherwise byte-identical.
 import { test } from "vitest";
-import { renderHook } from "../helper/render";
+import { renderHook } from "@solidjs/testing-library";
 
 import { usePrefersReducedMotion } from "../../src/util/usePrefersReducedMotion";
 import { Global } from "../../src/util/Global";

package/test/util/useUniqueId.spec.ts

@@ -5,7 +5,7 @@
 // spec's structure; the stability assertions hold by construction. Assertions
 // are otherwise byte-identical.
 import { describe, it, expect } from "vitest";
-import { renderHook } from "../helper/render";
+import { renderHook } from "@solidjs/testing-library";
 import { useUniqueId } from "../../src/util/useUniqueId";
 import { useIdFallback } from "../../src/util/useId";
 

package/test/zIndex/AllZIndexPortals.spec.tsx

@@ -10,7 +10,7 @@
 // `store.actions.zIndex.registerZIndexPortal(…)` + `flush()`.
 import { beforeEach, describe, expect, it } from "vitest";
 import { flush } from "solid-js";
-import { render } from "../helper/render";
+import { render } from "@solidjs/testing-library";
 import { RechartsStoreContext } from "../../src/state/RechartsStoreContext";
 import { AllZIndexPortals } from "../../src/zIndex/ZIndexPortal";
 import { createRechartsStore, type RechartsStore } from "../../src/state/store";

package/test/zIndex/DynamicZIndex.spec.tsx

@@ -13,7 +13,7 @@
 import { describe, it, expect } from "vitest";
 import { createSignal, flush } from "solid-js";
 import { LineChart, Line, XAxis, YAxis } from "../../src";
-import { fireEvent, render, screen } from "../helper/render";
+import { fireEvent, render, screen } from "@solidjs/testing-library";
 
 describe("Dynamic zIndex updates", () => {
   it("should keep the line in the DOM when zIndex changes dynamically", () => {

package/test/zIndex/ZIndexLayer.portalOwner.spec.tsx

@@ -9,7 +9,7 @@
 import { describe, expect, it } from "vitest";
 import { createSignal, flush } from "solid-js";
 import type { JSX } from "@solidjs/web";
-import { render, fireEvent } from "../helper/render";
+import { render, fireEvent } from "@solidjs/testing-library";
 import { BarChart, Bar } from "../../src";
 import type { AnimationController } from "../../src";
 import { AnimationControllerProvider } from "../../src/animation/useAnimationController";

package/test/zIndex/componentZIndex.spec.tsx

@@ -25,7 +25,7 @@ import {
   XAxis,
   YAxis,
 } from "../../src";
-import { render } from "../helper/render";
+import { render } from "@solidjs/testing-library";
 
 const data = [
   { name: "a", uv: 100 },

package/test/zIndex/multiChartZIndexIsolation.spec.tsx

@@ -10,7 +10,7 @@ import { describe, expect, it } from "vitest";
 import { createSignal, flush, Show } from "solid-js";
 import { Bar, BarChart, Pie, PieChart } from "../../src";
 import { assertNotNull } from "../helper/assertNotNull";
-import { render } from "../helper/render";
+import { render } from "@solidjs/testing-library";
 
 const barData = [
   { name: "a", uv: 100 },

package/test-results/.last-run.json

@@ -0,0 +1,4 @@
+{
+  "status": "failed",
+  "failedTests": []
+}

package/NEXT_SESSION_PROMPT.md

@@ -1,114 +0,0 @@
-# Session goal: grow the test suite (and fix what it surfaces)
-
-You are continuing a faithful port of **recharts 3.8.1 → SolidJS 2.0** living at
-`/Users/thomas/Downloads/solid-recharts/packages/solid-recharts`. The feature port is ~80%
-complete; **test coverage is the gap** — ~1217 cases vs recharts' ~3658 (~33%). Your job this
-session is to **port reference specs into the Solid suite**, and **fix any real port bugs the
-new tests surface**. Quality over volume: every test must be faithful and must pass for the
-right reason.
-
-## The reference
-
-recharts 3.8.1 source + tests are checked out at:
-
-- `/Users/thomas/Documents/Github/recharts-reference/src`
-- `/Users/thomas/Documents/Github/recharts-reference/test`
-
-Port the reference spec's _intent and exact assertions_ (golden numbers, geometry, counts),
-adapting only the React→Solid mechanics.
-
-## Non-negotiable conventions (these OVERRIDE defaults)
-
-1. **Gate after EVERY change**: `vp check --fix` (lint/format/type — must end at _0 errors_;
-   10 warnings is the known steady-state baseline) AND `vp test run` (must stay fully green).
-   Do NOT use `npx vitest` — use `vp test run <pattern>`.
-2. **No `any`, no `as`, no non-null `!` in src, no `@ts-expect-error`.** The lint is
-   type-aware and WILL catch these (it already caught a bad test this project). Use typed
-   coercion / helpers instead.
-3. **Faithful porting.** If a feature is genuinely deferred in the port (check the file's
-   header comment), don't assert it — write a _subset_ spec mirroring the existing ported
-   specs' style, and note in the spec header which reference assertions you omitted and why.
-   If the spec fails because the **port has a real bug or missing-but-claimed feature, FIX the
-   port** (faithfully to recharts), don't weaken the test.
-4. **Document deviations** in spec/source header comments (the codebase does this consistently
-   — match the surrounding style, comment density, and naming).
-
-## Solid 2.0 gotchas that WILL bite (all learned the hard way — see memory)
-
-- A global guard in `test/setup.ts` **fails any test on a non-allowlisted Solid diagnostic**
-  (STRICT_READ_UNTRACKED etc). Common fixes:
-  - Don't read a reactive/accessor value directly in `<Show when={...}>` static children —
-    use the accessor-child form `<Show when={obj()}>{(v) => ...}</Show>` with a TRUTHY object
-    `when`, OR a plain **ternary** in JSX for a captured non-reactive const (a
-    `<Show when={capturedConst}>` still trips STRICT_READ).
-  - Bake values into `<For>`-item descriptors; don't render recursive hierarchies via
-    components that read reactive `props.*`.
-- **`mouseenter`/`mouseleave` do NOT bubble.** Item handlers live on the wrapping node
-  `<Layer>` — `fireEvent.mouseEnter` the Layer `g`, not the inner shape.
-- **Bar item-hover tooltip needs `<Tooltip shared={false}>`** (shared tooltips use the
-  axis/mouse path, not item-enter).
-- Solid 2.0 **defers propagation to a flush boundary**: after a sync signal set, a memo read
-  in the same tick is stale until `flush()`. Tests call `flush()` after render and after
-  `fireEvent`. Use local values (not re-read memos) inside event handlers.
-- Test wrappers: use `props.children`, never destructure `{children}` (breaks the store).
-
-## Exact commands
-
-```
-cd /Users/thomas/Downloads/solid-recharts/packages/solid-recharts
-vp test run <Name>      # run one spec (substring match), e.g. vp test run ChartUtils
-vp test run             # full suite (currently 1217 passing / 115 files)
-vp check --fix          # the gate (0 errors / 10 warnings = clean)
-```
-
-## Prioritized worklist (port in this order — fastest/safest first)
-
-**Tier 1 — pure-function specs (no DOM, no flake, highest value).** These pin exact numeric
-behavior of code we already ship but barely test. Reference paths under `…/recharts-reference/test/`:
-
-- `util/ChartUtils.spec.tsx`, `util/BarUtils.spec.tsx`, `util/DataUtils.spec.ts` (extend ours)
-- `util/round.spec.ts`, `util/isWellBehavedNumber.spec.ts`, `util/getRelativeCoordinate.spec.ts`
-- `util/ChartUtils/{truncateByDomain,getStackedData,getCateCoordinateOfLine}.spec.*`
-- `util/scale/{getNiceTickValues,arithmetic,createCategoricalInverse}.spec.ts`
-- `util/cursor/{getCursorRectangle,getCursorPoints,getRadialCursorPoints}.spec.ts`
-- `util/payload/getUniqPayload.spec.ts`, `util/tooltip/translate.spec.ts`
-- `util/CartesianUtils/{CartesianUtils,rectWithPoints}.spec.ts`, `util/PolarUtils.spec.ts`
-- `util/resolveDefaultProps.spec.tsx` (NB: our port uses Solid `merge`, not resolveDefaultProps
-  — adapt or skip with a note), `util/isDomainSpecifiedByUser.spec.ts`, `util/TickUtils.spec.ts`
-- Also untested port units with NO ref-named spec but clearly testable: `src/util/getSliced.ts`,
-  `getEveryNth.ts`, `getActiveCoordinate.ts`, `YAxisUtils.ts`, `getRadiusAndStrokeWidthFromDot.ts`,
-  `ReduceCSSCalc.ts` — write fresh unit specs from the port's behavior + reference src.
-
-**Tier 2 — state selectors (test through the store; medium effort).**
-`state/selectors/*.spec.tsx` — `dataSelectors`, `axisSelectors`, `legendSelectors`,
-`lineSelectors`, `pieSelectors`, `scatterSelectors`, `radialBarSelectors`, `selectChartOffset`,
-`combiners/combineActiveTooltipIndex`. Use the existing `test/helper/render` + store patterns.
-
-**Tier 3 — component/integration specs (deepen behavior).**
-`component/{Text,Label,LabelList,Legend,DefaultTooltipContent,Cursor,ResponsiveContainer}.spec.tsx`,
-`cartesian/{Area,Line,Bar/Bar,Scatter,CartesianAxis,CartesianGrid,ErrorBar,Brush}.spec.tsx`,
-`polar/{Pie/Pie,Radar,RadialBar/RadialBar,PolarGrid,PolarAngleAxis,PolarRadiusAxis}.spec.tsx`,
-`chart/{ComposedChart,RadarChart,ScatterChart,CategoricalChart}.spec.tsx`. These are big in the
-reference — port the parity-critical subset and document omissions (the existing `*.spec.tsx`
-headers show the house style).
-
-## Working rhythm
-
-1. Pick the next worklist item. Read the reference spec + the port's source.
-2. Port the spec into the mirrored path under `test/` (match existing naming/structure).
-3. `vp test run <Name>`. If it fails: decide — port bug (fix src faithfully) vs deferred feature
-   (subset the spec + document). Never weaken a test to hide a real gap.
-4. `vp check --fix`. Confirm 0 errors.
-5. Periodically run the full `vp test run` to catch cross-file regressions.
-6. Update `MEMORY.md` + a memory file when you learn something non-obvious or finish a cluster.
-
-## Context to load first
-
-Read the memory index at
-`/Users/thomas/.claude/projects/-Users-thomas-Downloads-solid-recharts/memory/MEMORY.md` and the
-files it points to (especially `expectclean-or-diagnostics-silent.md`,
-`solid2-reactivity-timing.md`, `root-config-and-lint.md`, `custom-shape-render-props.md`) — they
-encode the gate, the diagnostic guard, and the reactivity rules above.
-
-Start with **Tier 1** and report progress in batches (files ported, tests added, any port bugs
-fixed). Keep the suite green the whole way.

package/src/state/reduxDevtoolsJsonStringifyReplacer.ts

@@ -1,15 +0,0 @@
-// Ported from recharts 3.8.1 src/state/reduxDevtoolsJsonStringifyReplacer.ts
-// Pure util — no framework surface — behavior is byte-identical to recharts.
-
-export function reduxDevtoolsJsonStringifyReplacer(key: string, value: unknown) {
-  if (value instanceof HTMLElement) {
-    return `HTMLElement <${value.tagName} class="${value.className}">`;
-  }
-  if (value === window) {
-    return "global.window";
-  }
-  if (key === "children" && typeof value === "object" && value !== null) {
-    return "<<CHILDREN>>";
-  }
-  return value;
-}

package/src/util/axisPropsAreEqual.ts

@@ -1,42 +0,0 @@
-// Ported from recharts 3.8.1 src/util/axisPropsAreEqual.ts (commit 7a23854).
-import { AxisRange } from "../state/selectors/axisSelectors";
-import { AxisDomain } from "./types";
-import { propsAreEqual } from "./propsAreEqual";
-
-function shortArraysAreEqual(
-  arr1: AxisDomain | AxisRange | undefined,
-  arr2: AxisDomain | AxisRange | undefined,
-): boolean {
-  if (arr1 === arr2) {
-    return true;
-  }
-
-  if (Array.isArray(arr1) && arr1.length === 2 && Array.isArray(arr2) && arr2.length === 2) {
-    return arr1[0] === arr2[0] && arr1[1] === arr2[1];
-  }
-
-  return false;
-}
-
-export function axisPropsAreEqual<
-  T extends Record<string, unknown> & {
-    domain?: AxisDomain;
-    range?: AxisRange;
-  },
->(prevProps: T, nextProps: T): boolean {
-  if (prevProps === nextProps) {
-    return true;
-  }
-  const { domain: prevDomain, range: prevRange, ...prevRest } = prevProps;
-  const { domain: nextDomain, range: nextRange, ...nextRest } = nextProps;
-
-  if (!shortArraysAreEqual(prevDomain, nextDomain)) {
-    return false;
-  }
-
-  if (!shortArraysAreEqual(prevRange, nextRange)) {
-    return false;
-  }
-
-  return propsAreEqual(prevRest, nextRest);
-}

package/src/util/resolveDefaultProps.tsx

@@ -1,8 +0,0 @@
-// SKIPPED — intentionally NOT ported to the SolidJS port.
-//
-// Reason: React defaultProps shim — use Solid merge()
-//
-// TODO: do not port this file as-is. The Solid-native port replaces it (see the
-// reason above). If a consumer needs this path, wire it to the Solid equivalent
-// instead. Tracked in scripts/porting-queue.mjs SKIP list and project memory.
-export {};

package/src/util/typedDataKey.ts

@@ -1,8 +0,0 @@
-// SKIPPED — intentionally NOT ported to the SolidJS port.
-//
-// Reason: already inlined as TypedDataKey in util/types.ts
-//
-// TODO: do not port this file as-is. The Solid-native port replaces it (see the
-// reason above). If a consumer needs this path, wire it to the Solid equivalent
-// instead. Tracked in scripts/porting-queue.mjs SKIP list and project memory.
-export {};

package/test/helper/render.ts

@@ -1,7 +0,0 @@
-// Test render helper, backed by the @solid-recharts/testing-library workspace
-// package (a vendored Solid 2.0 port of @solidjs/testing-library — the official
-// 0.8.x still targets Solid 1.x via the removed `solid-js/web` path). Specs
-// import `render`, `cleanup`, and the @testing-library/dom query/event helpers
-// (screen, fireEvent, waitFor, …) from here so there's a single swap point for
-// when the package is published to npm.
-export * from "@solid-recharts/testing-library";

package/test/state/reduxDevtoolsJsonStringifyReplacer.spec.ts

@@ -1,25 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { reduxDevtoolsJsonStringifyReplacer } from "../../src/state/reduxDevtoolsJsonStringifyReplacer";
-
-describe("reduxDevtoolsJsonStringifyReplacer", () => {
-  it("should return the original value if the value is not an object", () => {
-    expect(reduxDevtoolsJsonStringifyReplacer("", "foo")).toBe("foo");
-  });
-
-  it("should return string if the value is an HTML element", () => {
-    const p = document.createElement("p");
-    p.classList.add("my-example-class");
-    expect(reduxDevtoolsJsonStringifyReplacer("", p)).toBe(
-      'HTMLElement <P class="my-example-class">',
-    );
-  });
-
-  it("should return string if the value is a global window object", () => {
-    /*
-     * Firefox devtools throw exceptions when attempting to deeply serialize window object
-     * because some of the properties inside belong to another iframe
-     * and that other iframe sometimes has cross-origin access limitations.
-     */
-    expect(reduxDevtoolsJsonStringifyReplacer("", window)).toBe("global.window");
-  });
-});

package/test/util/axisPropsAreEqual.spec.ts

@@ -1,93 +0,0 @@
-// Ported from recharts 3.8.1 test/util/axisPropsAreEqual.spec.ts (commit 7a23854).
-// Solid deviation: the comparator is pure, so tests use plain prop records rather
-// than importing React-oriented axis prop types.
-import { describe, expect, it } from "vitest";
-import { axisPropsAreEqual } from "../../src/util/axisPropsAreEqual";
-import { AxisRange } from "../../src/state/selectors/axisSelectors";
-
-describe("axisPropsAreEqual", () => {
-  it("should return true for identical props", () => {
-    const props1 = { xAxisId: 1 };
-    const props2 = { xAxisId: 1 };
-    expect(axisPropsAreEqual(props1, props2)).toBe(true);
-  });
-
-  it("should return false for different props", () => {
-    const props1 = { width: "auto" };
-    const props2 = { width: "auto", height: "auto" };
-    expect(axisPropsAreEqual(props1, props2)).toBe(false);
-  });
-
-  it("should return false for different nested props", () => {
-    const props1 = { mirror: true, padding: { left: 0 } };
-    const props2 = { mirror: true, padding: { left: 10 } };
-    expect(axisPropsAreEqual(props1, props2)).toBe(false);
-  });
-
-  it("should return true for same reference nested props", () => {
-    const nested = { left: 0 };
-    const props1 = { minTickGap: 1, padding: nested };
-    const props2 = { minTickGap: 1, padding: nested };
-    expect(axisPropsAreEqual(props1, props2)).toBe(true);
-  });
-
-  it("should return true for same value, different reference, allowlisted nested props", () => {
-    const props1 = { axisLine: { x: 10, y: 20 } };
-    const props2 = { axisLine: { x: 10, y: 20 } };
-    expect(axisPropsAreEqual(props1, props2)).toBe(true);
-  });
-
-  it("should return false for different value, different reference, allowlisted nested props", () => {
-    const props1 = { axisLine: { x: 10, y: 20 } };
-    const props2 = { axisLine: { x: 10, y: 30 } };
-    expect(axisPropsAreEqual(props1, props2)).toBe(false);
-  });
-
-  it("should treat undefined and null as if they were equal", () => {
-    const props1: { label: null | undefined } = { label: undefined };
-    const props2: { label: null | undefined } = { label: null };
-    expect(axisPropsAreEqual(props1, props2)).toBe(true);
-  });
-
-  it("should treat positive and negative zero as equal", () => {
-    const props1 = { tickMargin: 0 };
-    const props2 = { tickMargin: -0 };
-    expect(axisPropsAreEqual(props1, props2)).toBe(true);
-  });
-
-  it("should treat NaN values as equal", () => {
-    const props1 = { angle: NaN };
-    const props2 = { angle: NaN };
-    expect(axisPropsAreEqual(props1, props2)).toBe(true);
-  });
-
-  it("should treat two equal domain arrays as equal", () => {
-    const props1 = { domain: [0, 100] };
-    const props2 = { domain: [0, 100] };
-    expect(axisPropsAreEqual(props1, props2)).toBe(true);
-  });
-
-  it("should treat two different domain arrays as different", () => {
-    const props1 = { domain: [0, 100] };
-    const props2 = { domain: [0, 200] };
-    expect(axisPropsAreEqual(props1, props2)).toBe(false);
-  });
-
-  it("should treat two equal range arrays as equal", () => {
-    const props1: { range: AxisRange } = { range: [0, 500] };
-    const props2: { range: AxisRange } = { range: [0, 500] };
-    expect(axisPropsAreEqual(props1, props2)).toBe(true);
-  });
-
-  it("should treat two different range arrays as different", () => {
-    const props1: { range: AxisRange } = { range: [0, 500] };
-    const props2: { range: AxisRange } = { range: [0, 600] };
-    expect(axisPropsAreEqual(props1, props2)).toBe(false);
-  });
-
-  it("should treat two same categorical domains as different", () => {
-    const props1 = { domain: ["a", "b", "c"] };
-    const props2 = { domain: ["a", "b", "c"] };
-    expect(axisPropsAreEqual(props1, props2)).toBe(false);
-  });
-});