* Fix callout formatting
* docs: convert remaining blockquote callouts to GitHub alert syntax
Converts all 341 remaining old-style callouts (> **Note:**, > NOTE:,
> **NOTE**:, > Tip:, > **Warning:**, etc.) across the docs to the
GitHub markdown alert syntax ([!NOTE], [!TIP], [!WARNING], [!IMPORTANT])
that tanstack.com renders as styled callouts.
Also fixes one pre-existing alert in client-side-vs-server-side.md that
had its content on the same line as the marker, and trailing whitespace
on the alert marker in the svelte quick-start.
Qualified callouts with custom titles (TypeScript Note, Framework note,
Naming note) are intentionally left as plain blockquotes since the alert
syntax does not support custom titles.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---------
Co-authored-by: Kevin Van Cott <kevinvandy656@gmail.com>
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
* fix(table-core): correct number-range, filter-depth, autoRemove, and custom faceting semantics
Four filtering-semantics bugs from the beta triage.
filterFn_inNumberRange matched non-numeric values: JavaScript's loose
relational coercion let null, '', and booleans slip into a numeric range
(null >= 0 && null <= 20 is true), so the auto-selected number filter
leaked empty rows into a [0, max] range on nullable numeric columns. The
filter now only matches real numbers. Numeric strings also stop
matching; `between`/`betweenInclusive` remain the hybrid string/number
range filters.
When maxLeafRowFilterDepth stopped the root-down filter recursion, the
kept rows' unfiltered descendants stayed visible through row.subRows but
never entered flatRows or rowsById, so facet counts and other
flat-representation consumers under-counted after filtering. Truncated
subtrees now join both. Scoped to the root-down path; the leaf-up path
drops truncated subRows entirely (pre-existing behavior) and is left as
a possible follow-up.
shouldAutoRemoveFilter ORed a hardcoded empty-string check over a custom
autoRemove, so a filter function that wanted to keep '' as a filter
value could not. A provided autoRemove is now authoritative for defined
values; undefined always clears, since it is the universal
setFilterValue(undefined) sentinel. Built-ins are unaffected: they all
test falsy values themselves.
Custom facetedUniqueValues/facetedMinMaxValues/facetedRowModel factories
were frozen by a redundant memoization layer in columnFacetingFeature.
The stock factories already memoize internally with the same
dependencies, so the API-layer memoDeps only served to cache custom
implementations against inputs they do not depend on. The API layer is
now a plain pass-through like every other row model: stock results stay
referentially stable and compute once per invalidation (pinned by
Map-identity tests), the no-factory fallback keeps a stable empty Map,
and custom factories own their memoization (tableMemo is exported for
this). The faceting guides now document the contract and their
server-side examples read live data through table.options.meta instead
of stale closures.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* fix(table-core): read live facet data in remaining server-side faceting examples
The alpine, ember, lit, and octane guides captured a one-time `await fetch`
result in the factory closure, so later server responses could never reach
either faceting API. They now read through `table.options.meta` inside the
returned functions like the other framework guides, using each framework's
own reactive idiom.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
Two independent clusters of default-behavior bugs from the beta triage.
Expanded and paginated state contents:
Expand-all materialized every id in `rowsById`, including leaf rows that
can never expand, so a serialized `ExpandedState` was polluted with dead
keys and `getExpandedDepth` was skewed by them. Materialization now writes
only ids where `row.getCanExpand()` is true, chosen over `subRows.length`
so `getRowCanExpand` lazy-load overrides stay expandable.
`getExpandedDepth` filters the same way, and `getIsAllRowsExpanded` now
only considers expandable rows so the materialized map still round-trips
as "all expanded" (a map of stale ids with no expandable rows is false).
Paginated `flatRows` pushed each row and then recursed into its subRows,
but page rows already contain expanded descendants inline, so those rows
appeared twice. The rebuild now dedupes by row id. Collapsed descendants
stay included, consistent with every other row model, where `flatRows`
ignores expansion state.
`row.toggleExpanded(bool)` and `table.toggleAllRowsExpanded(bool)` fired
`onExpandedChange` even when the requested state already matched, so
controlled consumers got spurious callbacks. Both now early-return.
Neither toggle consulted `row.getCanExpand()`, unlike their row-selection
equivalents, so a non-expandable row could be written into expanded state
imperatively. The expand direction is now guarded; collapsing is always
allowed so stale expanded ids can still be cleaned up.
Sorting toggle defaults:
`column.toggleSorting()` called `column.getNextSortingOrder(column)` with
no `multi` argument, so `enableMultiRemove` was dead on every path. The
argument is now forwarded as `multi && column.getCanMultiSort()`, matching
the multi-mode condition the updater itself uses. The public
`getNextSortingOrder` type now accepts the `multi` argument it always
supported at runtime.
`column.getAutoSortDir()` sampled only `flatRows[0]`, so a leading null or
a manual-sorting data swap flipped the inferred first direction mid-cycle
and silently dropped a state from the toggle cycle. It now samples the
first 10 rows for a non-nullish value, matching `getAutoSortFn`.
Docs: `sortUndefined: false` was documented as "considered tied" in all
framework sorting guides; undefined values are actually passed straight to
the sorting function with no special handling. Corrected, and the missing
`'first'`/`'last'` bullets were added to the generated reference.
Also fixes three crashes in the MRT examples surfaced while testing the
sorting changes. The MUI and Mantine sort labels read `sorting` off
`state`, which does not carry it, and crashed on `sorting.length`; they now
read it through `table.Subscribe` on `table.atoms.sorting`, which also
makes the badge reactive. The row-action edit handler passed a shallow row
copy to `setEditingRow`, breaking the row identity the edit modal needs.
`mrtRefsFeature` seeded the keyed `editInputRefs`/`filterInputRefs` bags
with `null` instead of `{}`, crashing on first keyed write. New e2e
coverage pins all three plus the sort-direction indicator.
Closes#6115Closes#5833Closes#6136Closes#4939Closes#4946Closes#5147Closes#5832
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
* fix: honor selection rules in select-all paths, add deselectParents option
Three coordinated row selection fixes for the v9 beta window:
- toggleAllRowsSelected and the getIsAllRowsSelected/getIsAllPageRowsSelected
getters now honor enableSubRowSelection: sub-rows whose ancestors block
descent are skipped by select-all and excluded from the all-selected
computation, matching what toggleAllPageRowsSelected already did (#5116)
- deselecting all rows now preserves the selection of rows whose
enableRowSelection resolves false; deselectAll: true and
resetRowSelection(true) remain the full-clear escapes (#5398)
- new opt-in deselectParents flag on ToggleSelectedOptions removes ancestor
row ids from the selection when a row is deselected, covering the
select-parent-then-deselect-child sequence without changing default state
semantics (#6049)
Eligibility walks are deduped with a per-pass ancestor cache (the
enableSubRowSelection predicate runs once per unique parent), and the
all-selected scans check the cheap isRowSelected lookup first so selected
rows skip capability checks entirely.
Includes 20 new tests, updated row-selection guides for all 10 frameworks
(the canonical checkbox snippet now shows the nested-data pattern), SKILL
updates, and refreshed triage notes.
Fixes#5116Fixes#5398Fixes#6049Fixes#4878Fixes#5416
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* docs(table-core): lock in deselectParents pruning contract for non-selectable ancestors
Review feedback suggested gating pruneAncestorRowIds on row_getCanSelect. That
would reintroduce the stale-parent state the opt-in exists to remove: a
skipped non-selectable ancestor keeps reporting getIsSelected() over a
deselected child. The enableRowSelection deselect guard is deliberately scoped
to the bulk select-all paths only; targeted deselection paths, including
pruning, may clear any id. Encode the decision in JSDoc, an implementation
comment, and a regression test.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
* fix: react adapter sync state
* Some changes
* refactor: move render-phase sync strategy into core reactivity bindings (#6459)
* refactor: move render-phase sync strategy into core reactivity bindings
Builds on the deferred controlled-state publication from this branch and
consolidates it behind a consistent adapter interface:
- TableReactivityBindings gains two optional properties describing the two
strategy axes: deferExternalStateSync (write-side: is setOptions a
notification-safe moment?) and commit (invalidation hook for readonly atoms
whose compute reads non-reactive plain options). constructTable warns in dev
when defer is set with plain options but no commit hook.
- table_setOptions consults the bindings flag instead of a per-call
{ syncExternalState } option, so an adapter's strategy is declared once.
- table_syncExternalStateToBaseAtoms replaces the arguments.length overloads
with an explicit `capturedState | null` sentinel, and now owns the commit
bump: it runs inside the write batch and fires even when nothing is
published, so ownership releases still invalidate subscribers.
- New renderPhaseReactivity preset in @tanstack/table-core/reactivity hosts
the live readonly-atom facade + commit atom (moved from the React adapter).
Store primitives are injected by the adapter so all atoms share one store
instance with user external atoms. Preact can adopt the same preset later.
- New createCommitFilteredSource replaces useTableSelector: because facade
snapshots are referentially stable, a reference check on the last snapshot
read is enough to skip the root hook's redundant post-commit notification.
This drops the committed-selection refs and the implicit requirement that
the selector's layout effect run before the publish effect.
- useTable: plain useSelector over the filtered source; the publish layout
effect is a single table_syncExternalStateToBaseAtoms call.
All 11 react-table tests from this branch pass unchanged. table-core: 1017
tests, types, lint, size-limit green. Both example e2e smoke suites pass.
Verified in basic-external-state (StrictMode + React Compiler + devtools):
one render pass and one commit per controlled update, no render-phase
warning, correct behavior through pagination/sorting/page-size/1M-row stress.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* fix: adopt render-phase reactivity preset in the preact adapter
Preact had the identical sync-options-during-render code as React and paid
the same cost silently: the mid-render store notification scheduled an extra
deferred render per controlled update (Preact never warns about it).
Same shape as the React adapter: preactReactivity collapses onto
renderPhaseReactivity with @tanstack/preact-store primitives, useTable defers
publication to an isomorphic layout effect with the captured controlled
state, and the root useSelector reads through createCommitFilteredSource.
New unit tests assert one render pass per controlled update with consistent
controlled/selected/atom/store/row-model reads, exactly one post-commit store
notification for external subscribers, and uncontrolled updates still
re-rendering. New e2e spec exercises controlled pagination in the
basic-external-state preact example. Types, lint, and build green.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* fix: adopt render-phase reactivity in the lit adapter, un-pin subscribe islands from stale renders
The lit basic-subscribe e2e regression had two stacked causes:
1. The subscribe directive returned noChange for host-driven re-renders with
an unchanged source + selector, so islands only ever updated from store
notifications. They previously received one for ANY setOptions call
because the aggregate state snapshot was rebuilt without a comparator;
the (correct) shallow compare on table.store stopped notifying for
options-only changes, pinning islands to stale row models after
Regenerate Data. The directive now re-renders islands on every host
update and adopts the latest template closure, while subscriptions still
drive updates between host renders.
2. Lit was the off-diagonal reactivity case: a reactive options store
written during render(), costing a second update cycle per interaction
(requestUpdate mid-update from the optionsStore subscription).
litReactivity now uses the renderPhaseReactivity preset with
@tanstack/lit-store primitives: plain options synced during render,
captured controlled state published from hostUpdated(), and the
controller's root subscription reads through createCommitFilteredSource.
The optionsStore subscription is gone; options changes flow through host
renders (lit reactive properties), which 30 of 31 lit examples already
use. basic-subscribe was the lone outlier constructing the table once
and pushing data via imperative setOptions in updated() — it now
re-syncs options per render pass like the rest.
Measured on basic-subscribe: Regenerate Data works again with one host
update (previously two, with stale islands), zero idle update churn, and a
row-selection click still updates only its island with zero host updates.
Unit tests: directive/controller suites updated to the new contract plus a
hostUpdated publication test (6/6). All 34 lit example e2e suites pass,
including the previously failing basic-subscribe. Types, lint, build green.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* test: drop dev-warning assertion to match removed bindings coherence warning
The constructTable dev warning for deferExternalStateSync-without-commit was
removed in the previous commit; align the test suite (1010 tests green).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* ci: apply automated fixes
* consolidate constructTable features loop again
* fix: keep the two-phase feature lifecycle in the consolidated features loop
The consolidated loop interleaved constructTableAPIs with
initTableInstanceData per feature (and ran APIs first within each feature),
breaking the lifecycle contract from #6446 that constructTable.test.ts
encodes: every feature's table instance data initializes before ANY table
APIs are constructed, so API constructors can read instance data owned by
other features and init hooks observe a pre-API table.
Keep the consolidation of the init-fn collection with instance-data init
(one phase-1 loop writing the precomputed arrays directly), and restore
constructTableAPIs as its own second pass.
table-core: 1097/1097. React/preact/lit adapter suites green.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* refactor!: process feature lifecycle hooks in a single pass
Drop the two-phase construction contract (all initTableInstanceData before
any constructTableAPIs). Every in-repo hook is pure property assignment with
lazy API closures, so the phase barrier bought nothing; features are now
processed in one registration-order pass with each feature's instance data
initialized just before its own APIs are constructed.
New contract, encoded in the lifecycle test and documented in the
custom-features guides and TableFeature jsdoc: hooks may rely on data and
APIs of features registered earlier; eager cross-feature reads belong in
lazy API bodies.
table-core 1097/1097; react/preact/lit adapter suites green.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* refactor: require precomputed instance-init fn arrays on the table type
constructTable always assigns the five _*InstanceInitFns arrays before any
constructor can run, so model them as required and drop the non-null
assertions at the use sites (including the leftover one in buildHeaderGroups
that eslint flagged as unnecessary).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* clean up
* fix some issues exposed by MRT examples
* add more react smoke tests
---------
Co-authored-by: Kevin Van Cott <kevinvandy656@gmail.com>
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* perf: pre-compute instance init functions
When we construct a row, we iterate over the table's features and
initialise any which have an `initRowInstanceData`.
This is expensive since most don't have such a method.
We actually know when we construct the table which features have this
method. This changes the table construction to store the initialisers up
front so when we create a row, we can just iterate the already known
initialisers.
* fix(table-core): bind initialiser to feature
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
* cache init functions consistently for all table objects
---------
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
Co-authored-by: Kevin Van Cott <kevinvandy656@gmail.com>
* fix: add back sub-rows onto aggregate context
* aggregate from sub-rows by default first like v8 behavior
* new APIs for custom aggregation depths
* fix example signatures
* update docs
Clarify column visibility toggle labels
Column visibility menus render column objects, not active header objects, so rendering columnDef.header directly can fail or confuse users when headers are JSX/templates or when columns are hidden. The guide now shows a stable label map fallback and calls out flexRender as the correct path for real header rendering.
Related: TanStack/table#5751
Confidence: high
Scope-risk: narrow
Tested: pnpm prettier --write docs/framework/react/guide/column-visibility.md; pnpm test:docs
Not-tested: Full repository test suite
* feat: batch row selection
* fix tests
* pr feedback and add migration guide note
* no more e2e in pr
* fix angular examples double building in ci tests
* fix type
* feat: update column pinning terminology from left/right to start/end
* update beta number
* update variable names and clarify left to right associations
* feat: implement fine-grained rerendering control with an async Lit directive
An async Lit directe `subscribe` is implemented to allow for fine-grained reactivity and rerendering of templates.
To support this, `@tanstack/lit-store` is integrated.
* fix package.json
* fix a ton of stuff
* regen docs
---------
Co-authored-by: Kevin Van Cott <kevinvandy656@gmail.com>