# React performance fixes — working samples

Copy-ready fixes for the findings in `SKILL.md` §3–§5. Every sample includes its imports. Apply one at a time and re-measure.

Sources: https://react.dev/reference/react · https://tanstack.com/virtual/latest · https://react.dev/learn/react-compiler/installation · https://developer.chrome.com/docs/web-platform/scheduler-yield

## 1. Virtualised list (`@tanstack/react-virtual`)

Use above roughly 100 rendered rows. Fixed row height (`estimateSize` returning a constant) is much cheaper than measured rows.

```tsx
import { useRef } from 'react';
import { useVirtualizer } from '@tanstack/react-virtual';

export function OrderRows({ orders }: { orders: Order[] }) {
  const parentRef = useRef<HTMLDivElement>(null);
  const virtualizer = useVirtualizer({
    count: orders.length,
    getScrollElement: () => parentRef.current,
    estimateSize: () => 56,
    overscan: 8,
  });

  return (
    <div ref={parentRef} style={{ height: 600, overflow: 'auto' }}>
      <div style={{ height: virtualizer.getTotalSize(), position: 'relative' }}>
        {virtualizer.getVirtualItems().map((item) => (
          <div
            key={orders[item.index].id}
            style={{ position: 'absolute', top: 0, left: 0, width: '100%', height: item.size, transform: `translateY(${item.start}px)` }}
          >
            <OrderRow order={orders[item.index]} />
          </div>
        ))}
      </div>
    </div>
  );
}
```

Variable heights: drop the `height` from the row style and pass `ref={virtualizer.measureElement}` plus `data-index={item.index}` on the row element.

`react-window` is an alternative, but only its **v2** API (`List` with a `rowComponent` prop) exists today — `FixedSizeList`/`VariableSizeList` were removed, so any v1 snippet will not compile.

## 2. Typing lag: keep the input urgent, defer the view

```tsx
import { useDeferredValue, useMemo, useState } from 'react';

export function OrderSearch({ orders }: { orders: Order[] }) {
  const [query, setQuery] = useState('');
  const deferredQuery = useDeferredValue(query);          // lags behind under load
  const results = useMemo(
    () => orders.filter((o) => o.customer.toLowerCase().includes(deferredQuery.toLowerCase())),
    [orders, deferredQuery],
  );
  const stale = query !== deferredQuery;

  return (
    <>
      <input value={query} onChange={(e) => setQuery(e.target.value)} aria-label="Search orders" />
      <div style={{ opacity: stale ? 0.6 : 1 }}>
        <OrderRows orders={results} />
      </div>
    </>
  );
}
```

Never debounce the input's own state — the echo must be instant. Debounce the *request*, defer the *derived view*.

For a navigation or tab switch that renders a lot, wrap the state update instead:

```tsx
import { startTransition } from 'react';
startTransition(() => setTab('analytics'));
```

## 3. Keep expensive UI mounted without paying for it (`<Activity>`, React 19.2)

```tsx
import { Activity } from 'react';

export function Workspace({ tab }: { tab: 'editor' | 'preview' }) {
  return (
    <>
      <Activity mode={tab === 'editor' ? 'visible' : 'hidden'}><Editor /></Activity>
      <Activity mode={tab === 'preview' ? 'visible' : 'hidden'}><Preview /></Activity>
    </>
  );
}
```

Hidden children keep their state and DOM, their effects are cleaned up, and React renders them at a lower priority. Use it when re-mounting is the expensive part (editors, maps, long scroll positions); plain unmounting is still the default.

## 4. Break up a long task

```ts
async function indexAll(records: Record[]) {
  for (const [i, record] of records.entries()) {
    index(record);
    if (i % 200 === 0) await yieldToMain();
  }
}

function yieldToMain(): Promise<void> {
  if ('scheduler' in globalThis && 'yield' in (globalThis as any).scheduler) {
    return (globalThis as any).scheduler.yield();
  }
  return new Promise((resolve) => setTimeout(resolve, 0));
}
```

`scheduler.yield()` returns to the browser but keeps the continuation at the front of the queue, so unlike `setTimeout(…, 0)` the work is not starved by unrelated tasks. Feature-detect it.

Work that never needs the DOM belongs in a worker instead:

```ts
// search.worker.ts
self.onmessage = (e: MessageEvent<{ q: string; rows: Row[] }>) => {
  self.postMessage(rank(e.data.q, e.data.rows));
};

// component
const worker = useMemo(() => new Worker(new URL('./search.worker.ts', import.meta.url), { type: 'module' }), []);
useEffect(() => () => worker.terminate(), [worker]);
```

## 5. Resource hints from React 19

```tsx
import { preload, preinit, prefetchDNS } from 'react-dom';

preload('/fonts/inter-latin.woff2', { as: 'font', type: 'font/woff2', crossOrigin: 'anonymous' });
preinit('https://cdn.example.com/widget.js', { as: 'script' });
prefetchDNS('https://images.example.com');
```

Call them during render of the component that will need the resource; React hoists the tags and de-duplicates them. Preload exactly one font file and the LCP image — a preload list is a priority list, and everything preloaded competes with everything else.

LCP image rules: real dimensions, `sizes` matching the layout, AVIF/WebP, `fetchPriority="high"`, never `loading="lazy"`. In `next/image` 16 the `priority` prop is deprecated in favour of `preload`.

## 6. Enable the React Compiler

Vite with `@vitejs/plugin-react` 6+:

```js
// vite.config.js
import { defineConfig } from 'vite';
import react, { reactCompilerPreset } from '@vitejs/plugin-react';
import babel from '@rolldown/plugin-babel';

export default defineConfig({
  plugins: [react(), babel({ presets: [reactCompilerPreset()] })],
});
```

Older plugin versions, or plain Babel:

```js
// babel.config.js — the compiler plugin must run first
module.exports = { plugins: [['babel-plugin-react-compiler', { target: '19' }]] };
```

`target: '17'` or `'18'` compiles for older React, with `react-compiler-runtime` installed. Next.js: `reactCompiler: true` in `next.config.ts`.

Then make the bail-outs visible:

```js
// eslint.config.js
import reactHooks from 'eslint-plugin-react-hooks';
export default [reactHooks.configs['recommended-latest']];
```

The lint output names the exact line that stopped a component from compiling (mutation during render, conditional hook, `ref.current` read in render). Fix those before adding a single `useMemo` — and delete manual memoisation from components the compiler now handles.
