0
Fork 0
mirror of https://github.com/TanStack/router.git synced 2026-11-16 19:38:07 +00:00
router/benchmarks/client-nav
Brenley Dueck acd08ef685
chore(solid): bump to solid-js 2.0.0-rc.16 and @solidjs/vite-plugin 3.0.0-next.51 (#8751)
* chore(solid): bump to solid-js 2.0.0-rc.15 and @solidjs/vite-plugin 3.0.0-next.50

Bump solid-js and @solidjs/web to ^2.0.0-rc.15 and @solidjs/vite-plugin
to ^3.0.0-next.50 across the monorepo, along with the webpack example's
@solidjs/babel-plugin, the @rsbuild/plugin-solid compiler overrides and
the Solid packages' peer floors. Bump @tanstack/solid-query to
^6.0.0-rc.5 and move @tanstack/solid-query-devtools off its exact rc.1
pin to ^6.0.0-rc.5, whose solid-js imports all exist in rc.15.

In rc.15 a parent render effect runs before the Outlet's DOM swap within
the same commit, so the persistent-observer test now samples the DOM at
the end of the commit instead of mid-flush.

* fix(solid-router): render Await children with streamed data during hydration

On the client, Await calls defer() on a promise that seroval has already
resolved, but defer() only records the result in a .then callback, so the
synchronous hydration pass read status 'pending' and passed undefined to
the children. rc.13 hid this by reusing the server DOM; rc.15 evaluates the
children's expressions and the route errored. Read seroval's synchronous
s/v markers while the deferred state is still pending.

* chore(solid): bump to solid-js 2.0.0-rc.16 and @solidjs/vite-plugin 3.0.0-next.51

@solidjs/vite-plugin 3.0.0-next.51 no longer adds a $$moduleUrl export to
SSR entry chunks (solidjs/solid-vite-plugin#423), which workerd rejected
in the basic-cloudflare e2e. It peer-requires solid-js rc.16, so the
runtime, babel plugin, rsbuild compiler overrides and peer floors move to
rc.16 too.

rc.16's solid-js dev build reads DEV from @solidjs/signals at load time,
so the vitest alias of @solidjs/signals to solid-js now resolves to a
circular import and every suite failed with "reading 'guideUrl'". Drop
the alias from solid-router and the search-validator-adapters example.

The lockfile keeps the base branch's Babel resolutions; letting pnpm
re-resolve them gave router-plugin two @babel/types copies.

* chore: restore e2e test-results files removed by accident
History 2026-10-21 16:43:13 -05:00
..
react feat(benchmarks): client-side CPU benchmark scenario suite (#7732) 2026-07-03 08:18:08 +02:00
scenarios Merge branch 'main' into upgrade-solidjs-rc-0-main-merge 2026-08-12 23:09:21 -05:00
solid Upgrade solidjs rc 0 and rename vite-plugin-solid to @solidjs/vite-plugin 2026-08-12 20:21:16 -05:00
vue feat(benchmarks): client-side CPU benchmark scenario suite (#7732) 2026-07-03 08:18:08 +02:00
jsdom.ts feat(benchmarks): client-side CPU benchmark scenario suite (#7732) 2026-07-03 08:18:08 +02:00
package.json chore(solid): bump to solid-js 2.0.0-rc.16 and @solidjs/vite-plugin 3.0.0-next.51 (#8751) 2026-10-21 16:43:13 -05:00
README.md feat(benchmarks): client-side CPU benchmark scenario suite (#7732) 2026-07-03 08:18:08 +02:00
setup-helpers.ts chore: merge main to solid v2 (#7105) 2026-04-05 20:56:19 +02:00
tsconfig.json test: add cross-framework client navigation benchmarks (#6800) 2026-03-02 21:23:53 +01:00
vitest.config.ts feat(benchmarks): client-side CPU benchmark scenario suite (#7732) 2026-07-03 08:18:08 +02:00
vitest.react.config.ts feat(benchmarks): client-side CPU benchmark scenario suite (#7732) 2026-07-03 08:18:08 +02:00
vitest.setup.ts test: add cross-framework client navigation benchmarks (#6800) 2026-03-02 21:23:53 +01:00
vitest.solid.config.ts feat(benchmarks): client-side CPU benchmark scenario suite (#7732) 2026-07-03 08:18:08 +02:00
vitest.vue.config.ts feat(benchmarks): client-side CPU benchmark scenario suite (#7732) 2026-07-03 08:18:08 +02:00

Client Navigation Benchmarks

Cross-framework client-side CPU benchmarks for:

  • @tanstack/react-router
  • @tanstack/solid-router
  • @tanstack/vue-router

The benchmarks run in jsdom against production builds of real apps, and are tracked in CI by CodSpeed (simulation mode).

Scope: these benchmarks cover the standalone client router only. The client side of TanStack Start (hydration of a server-rendered document, streamed payload consumption, server-function calls from the client, ...) is not covered here; the server side of Start is covered by benchmarks/ssr.

Layout

  • react/, solid/, vue/ - baseline benchmark (mixed navigation loop) + Vitest config
  • vitest.react.config.ts, vitest.solid.config.ts, vitest.vue.config.ts - per-framework aggregate configs that run the baseline first, then scenario projects
  • scenarios/harness.ts - shared scenario runner (mount, link-click steps, onRendered synchronization)
  • scenarios/<scenario>/shared.ts - framework-agnostic scenario definition (workload data, step sequence, assertions, bench options)
  • scenarios/<scenario>/<framework>/ - isolated scenario apps

Scenario app layout:

scenarios/<scenario>/<framework>/
  vite.config.ts
  speed.bench.ts
  speed.flame.ts
  setup.ts
  project.json
  tsconfig.json
  src/
    main.tsx
    routeTree.gen.ts
    routes/

Scenario apps use file-based routing (@tanstack/router-plugin) with a generated routeTree.gen.ts, like a regular user app. Each scenario uses one app per framework instead of sharing routes in the baseline app. This keeps route-tree size and router options isolated so one scenario cannot shift another scenario's numbers. The existing baseline apps and bench names stay stable for CodSpeed continuity.

Scenario Responsibilities

Each scenario isolates one client-side responsibility so benchmark changes can be attributed to a specific feature area.

Scenario Client-side responsibility
react/, solid/, vue/ baseline apps Mixed navigation loop: path params, search params, route context, and useParams/useSearch/useLoaderData selector subscriptions.
async-pipeline The router's async pipeline via counted 0ms timer hops: async loaders (transition-held navigation), async beforeLoad context, and parallel nested async loaders. Component-level Await/Suspense is excluded: React 19 throttles Suspense reveals by ~300ms wall-clock, which is inherently non-deterministic to benchmark.
control-flow Loader-thrown redirect (including a 2-hop chain), notFound() with notFoundComponent, loader errors with errorComponent, and boundary reset on recovery navigation.
head HeadContent per-navigation work: nested route head() evaluation, title/meta/link dedupe across matches, and head tag DOM updates during navigation.
history History push/replace/back/forward traversal, location masking, registered-but-never-blocking useBlocker, and useCanGoBack/useLocation subscriptions.
links Per-navigation cost of ~200 mounted <Link>s: link prop building, active-state recompute across activeOptions variants, activeProps swaps, and useMatchRoute probes (the MatchRoute component is avoided: vue-router's implementation leaks one subscription per render).
loaders Client loader dispatch: always-stale re-runs (staleTime: 0), cached revisits (re-run once per lap by the invalidate step), loaderDeps-keyed caching, router.invalidate(), and useLoaderData selectors.
mount Cold start: createRouter (route-tree processing) + first render + initial router.load() + unmount, with a fresh router per mount. The only scenario measuring router creation.
nested-params Deep nesting (8 dynamic levels): per-level params.parse/stringify, beforeLoad context accumulation across matches, and per-level useParams/useRouteContext subscriptions. Param values include characters requiring percent-encoding (as do route-tree-scale's), so segment encode/decode paths run on every navigation.
preload Intent preloading from hover events, programmatic router.preloadRoute, deterministic preload cache behavior (defaultPreloadStaleTime: 0), and commit-time cache maintenance.
rewrites Composed client-side location rewrites: router basepath plus a locale input/output rewrite pair, running on every href build and location parse (the client analog of the SSR rewrites scenario).
route-tree-scale Route matching and link-target resolution on a wide (~40 route) tree mixing static, dynamic, prefixed-param, splat, pathless-layout, and route-group paths, with autoCodeSplitting enabled so navigations also resolve lazy route chunks.
search-params validateSearch execution, search middlewares (retainSearchParams/stripSearchParams), functional search updaters, structural sharing, and useSearch selector subscriptions.

Conventions

  • Apps are built with NODE_ENV=production (minify: false) into dist/app.js; benches import the built bundle, so production package builds and production JSX output are measured, not dev transforms.
  • Scenarios behave like a real user app: navigation happens through <Link> clicks dispatched on real anchor elements (unless a scenario specifically measures the imperative API), the router uses the default browser history, and scrollRestoration is enabled.
  • Each benchmark iteration advances a fixed, circular sequence of steps; every step awaits the router's onRendered event, so render work is included and steps cannot overlap. No two consecutive steps may target the same location, and the sequence ends back on the initial route.
  • Setup runs one warm-up lap through the sequence and asserts each step's observable output (e.g. document.title), so a scenario that silently stops doing its work fails instead of reporting a fast time.
  • Determinism: no wall-clock timers (async work is resolved promises or counted setTimeout(0) hops), staleTime/gcTime only ever 0 or effectively-infinite, no Math.random/Date.now in the measured loop. Scroll restoration uses getScrollRestorationKey: (location) => location.pathname so its cache stays bounded (the default random per-entry key grows one cache entry per push navigation). The mount scenario opts out of scrollRestoration entirely and destroys its history on unmount — both register page-lifetime globals that would leak across its mount/unmount loop.
  • Push-only step laps grow jsdom's session-history entry list over a run (jsdom never truncates entries behind the current index). Per-push cost stays O(1) so timings are unaffected; only the history scenario needs — and has — a lap that is depth-stationary.
  • Calibration: pick per-iteration step counts so a bench's vitest bench run stays roughly between 8 and 30 seconds (long enough to average out, short enough for CI).

Run

Run all benchmarks through Nx so dependency builds are part of the graph:

CI=1 NX_DAEMON=false pnpm nx run @benchmarks/client-nav:test:perf --outputStyle=stream --skipRemoteCache

Run framework-specific benchmarks (baseline + all scenarios):

CI=1 NX_DAEMON=false pnpm nx run @benchmarks/client-nav:test:perf:react --outputStyle=stream --skipRemoteCache
CI=1 NX_DAEMON=false pnpm nx run @benchmarks/client-nav:test:perf:solid --outputStyle=stream --skipRemoteCache
CI=1 NX_DAEMON=false pnpm nx run @benchmarks/client-nav:test:perf:vue --outputStyle=stream --skipRemoteCache

Run a single scenario app manually (after building it through Nx):

CI=1 NX_DAEMON=false pnpm nx run @benchmarks/client-nav-<scenario>-<framework>:build:client --outputStyle=stream --skipRemoteCache
cd benchmarks/client-nav && NODE_ENV=production vitest bench --config ./scenarios/<scenario>/<framework>/vite.config.ts

Run framework-specific flame benchmarks (10 second loop, profiled with @platformatic/flame, forced to NODE_ENV=production):

# baseline
CI=1 NX_DAEMON=false pnpm nx run @benchmarks/client-nav:test:flame:react --outputStyle=stream --skipRemoteCache
CI=1 NX_DAEMON=false pnpm nx run @benchmarks/client-nav:test:flame:solid --outputStyle=stream --skipRemoteCache
CI=1 NX_DAEMON=false pnpm nx run @benchmarks/client-nav:test:flame:vue --outputStyle=stream --skipRemoteCache
# scenarios
CI=1 NX_DAEMON=false pnpm nx run @benchmarks/client-nav-<scenario>-<framework>:test:flame --outputStyle=stream --skipRemoteCache

Typecheck benchmark sources (baseline + scenarios):

CI=1 NX_DAEMON=false pnpm nx run @benchmarks/client-nav:test:types --outputStyle=stream --skipRemoteCache