# Rendering, lists and off-main-thread work

Open this for the concrete recipe once the profiler has named the bucket. Verified 2026-09 against https://material.angular.dev/cdk/scrolling/overview, https://angular.dev/api/core/afterNextRender and https://angular.dev/guide/zoneless.

## 1. CDK virtual scroll

```ts
import { Component, ChangeDetectionStrategy, input } from '@angular/core';
import { ScrollingModule } from '@angular/cdk/scrolling';
import { OrderRow } from './order-row';
import type { Order } from '../model/order';

@Component({
  selector: 'app-order-list',
  imports: [ScrollingModule, OrderRow],
  changeDetection: ChangeDetectionStrategy.OnPush,
  styles: `cdk-virtual-scroll-viewport { height: 70vh; }`,
  template: `
    <cdk-virtual-scroll-viewport itemSize="48">
      <app-order-row *cdkVirtualFor="let order of orders(); trackBy: byId" [order]="order" />
    </cdk-virtual-scroll-viewport>`,
})
export class OrderList {
  readonly orders = input.required<readonly Order[]>();
  protected byId = (_: number, order: Order) => order.id;
}
```

- `itemSize` must match the rendered row height, or the scrollbar drifts and rows flicker. Fix the row height in CSS; it is worth the design conversation.
- `*cdkVirtualFor` is a structural directive, so it is one of the few places `trackBy` (not `@for … track`) is still the syntax.
- Variable-height rows need `autosize` from `@angular/cdk-experimental/scrolling`; it is slower and less stable, so prefer a fixed height.
- The viewport needs a bounded height. A viewport inside a growing container renders everything and the whole exercise is wasted.

**Prefer server pagination.** Virtual scroll fixes the DOM cost but not the payload, the JSON parse or the memory. Ten thousand rows over the wire is a network problem wearing a rendering costume.

## 2. Large tables

| Pressure | Move |
|---|---|
| Many rows | Server-side pagination first; CDK virtual scroll if the data must be local |
| Many columns | Render only the visible column set; horizontal virtualisation is rarely worth its complexity |
| Sorting/filtering feels slow | Do it on the server. `MatTableDataSource` sorts and filters the whole array on the main thread on every keystroke |
| Every row re-renders on one cell change | Row is its own `OnPush` component taking a prepared view-model `input()`, so a changed reference touches one row |
| Inline editing | Keep the edited row's state in the row component; do not lift it into a shared signal that every row reads |

Precompute the row view model once, in a `computed()` over the source array, so the template does no formatting:

```ts
protected readonly rows = computed(() =>
  this.orders().map((o) => ({ id: o.id, number: o.number, total: this.money.format(o.total), overdue: !o.paid })));
```

## 3. Debounce without lag

```ts
import { Component, ChangeDetectionStrategy, signal } from '@angular/core';
import { toSignal, toObservable } from '@angular/core/rxjs-interop';
import { debounceTime, distinctUntilChanged } from 'rxjs';

@Component({ /* … */ changeDetection: ChangeDetectionStrategy.OnPush })
export class OrderFilter {
  readonly text = signal('');                                   // echoes the keystroke immediately
  readonly debounced = toSignal(
    toObservable(this.text).pipe(debounceTime(300), distinctUntilChanged()),
    { initialValue: '' },
  );                                                            // drives the query
}
```

Binding the input to the debounced value instead makes typing feel broken; the split above keeps the field responsive while the expensive consumer waits.

## 4. DOM measurement

```ts
import { Component, ElementRef, afterNextRender, inject, signal } from '@angular/core';

@Component({ /* … */ })
export class Sticky {
  private readonly host = inject(ElementRef<HTMLElement>);
  protected readonly height = signal(0);

  constructor() {
    afterNextRender({ read: () => this.height.set(this.host.nativeElement.offsetHeight) });
  }
}
```

- `afterNextRender` runs once; `afterEveryRender` runs after each render. `afterRender` was renamed in v20 and no longer exists, so code using it does not compile on supported versions.
- Phases are the object keys — `earlyRead`, `write`, `mixedReadWrite`, `read` — and they batch all components' reads before all writes, which is what avoids layout thrash. There is no `AfterRenderPhase` enum any more.
- Both are browser-only: they do not run during server rendering, which makes them the correct home for `window`/`document` work.
- Never `setTimeout(0)` for this. It runs at an unrelated moment and reintroduces the thrash the phases exist to prevent.

## 5. Off the main thread

```bash
ng generate web-worker sorting
```

Worth it for sorting or transforming tens of thousands of records, parsing large CSV/JSON, crypto, and image manipulation. Not worth it for anything under a few milliseconds — the structured-clone cost of the payload can exceed the work. Measure the round trip before keeping it; transfer `ArrayBuffer`s rather than object graphs where you can.

## 6. CSS-level wins

- `content-visibility: auto` with `contain-intrinsic-size: <approx height>` on long off-screen sections skips their layout and paint until they approach the viewport. The intrinsic size is required, or the scrollbar jumps.
- `will-change` only on an element that is actively animating, and removed afterwards — each one costs a compositor layer and memory.
- Avoid `ViewEncapsulation.None` with deep selectors: the style becomes global and every DOM change triggers a wider style recalculation.
- Reserve space for images, ads and late-loading widgets (`width`/`height`, `aspect-ratio`, or a sized `@placeholder`) — this is the whole of CLS.

## 7. Zone-only escape hatches

These apply only while `zone.js` is still loaded (v20 apps that have not opted in to zoneless, or older codebases):

- `NgZone.runOutsideAngular(() => …)` for `scroll`, `mousemove`, `requestAnimationFrame` loops and third-party widgets, re-entering with `ngZone.run()` only when state must update.
- After removing `zone.js`, delete these calls: outside a zone they are a no-op with a misleading name, and they hide the fact that the notification now has to come from a signal write, a listener or `markForCheck()`.
