TanStack/form
Form
TanStack Form is a cross-framework form state management library that provides typed fields, validation, and submission across React, Vue, Angular, Solid, Lit, Svelte, and Preact. It uses a shared form model that adapts to different UI frameworks while preserving the same validation and submission logic, and offers headless form controls that impose no UI markup, letting developers bring their own inputs and design system.
The library distinguishes itself through granular state subscription, where components subscribe to narrow slices of form or field state using reactive primitives, so only the relevant UI re-renders on each change instead of the entire component tree. It supports typed form validation with full TypeScript inference, running synchronous validators on field changes and debounced asynchronous checks for slow business rules, keeping field names, values, and errors connected through refactors.
The project covers form field definition with type-safe APIs, submission of typed form data with inferred value shapes, and validation with both sync and async rules. It provides framework-specific adapters while keeping the same typed form model and validation strategy, and supports subscribing to granular form or field state to prevent unnecessary re-renders on large forms.
Features
- Cross-Framework Form Libraries - A cross-framework form state management library providing typed fields, validation, and submission across multiple UI frameworks.
- Async Form Validators - Runs synchronous validators per field and debounced asynchronous checks for slow business rules.
- Async Validators - Runs debounced async validators per field that keep the form responsive during slow business rule checks.
- Async Form Validators - Runs synchronous validators on field changes and debounced asynchronous checks for slow business rules.
- Typed Validators - Defines form fields with full TypeScript inference and runs sync or async validators that keep field names, values, and errors connected.
- Header Groupings - Computes nested header levels into groups, each with headers that offer header-specific APIs.
- Stale Cache Refetching - Keeps local data synchronized with the server by refetching when the application detects stale information.
- Granular State Subscriptions - Subscribes components to narrow slices of state so only relevant UI re-renders on each change.
- Framework-Specific Integrations - Provides framework-specific adapters so the same store works across React, Solid, Vue, Angular, Svelte, and Lit.
- Headless Component Logic - Provides framework-agnostic hooks and controllers for UI state management, letting developers bring their own markup and design system while sharing the same logic across React, Vue, Angular, and others.
- Schema-Driven Type Inference - Derives TypeScript types from Zod schemas at compile time, ensuring tool inputs, outputs, and form values remain type-safe across refactors without manual type declarations.
- Schema Type Inference - Derives TypeScript types from Zod schemas to ensure tool inputs and outputs match declared interfaces.
- Data Table State Managers - Provides a core table object that exposes both the current state and programmatic methods for manipulation.
- Column Definitions - Defines a column's data model, display template, and behavior through a declarative configuration object.
- Form and Input Management - Provides a shared typed form model that works across React, Vue, Angular, Solid, Lit, Svelte, and Preact.
- Cross-Framework Form Models - Provides a shared typed form model that works across React, Vue, Angular, Solid, Lit, Svelte, and Preact.
- Form State Management - Handles form state, validation, and submission with type-safe APIs across multiple frontend frameworks.
- Type-Safe Form Submissions - Passes the inferred value shape to submit handlers, eliminating hand-assembled payloads and keeping types through submission.
- Headless Form Management - Provides headless form controls that impose no UI markup, letting developers bring their own inputs and design system.
- Table Cell Definitions - Exposes row and cell objects that mirror the underlying data and provide APIs for per-row and per-cell operations.
- Form Field State Management - Defines fields with full TypeScript inference for values, errors, validators, and submit payloads, keeping the entire form model type-safe.
- Typed Field Definitions - Defines form fields with full TypeScript inference so field names, values, validators, and errors stay connected through refactors.
- Form State Subscriptions - Provides reactive subscriptions that let components observe only the specific form state they need.
- Granular Subscriptions - Subscribes components to narrow slices of form or field state so only the relevant UI re-renders on each change.
- Form Type Narrowing - Passes the inferred value shape of the entire form to submit handlers, eliminating hand-assembled payloads.
- Typed Route Navigators - Creates a contract from route files that connects params, search schemas, loader data, and links into a type-safe API.
- State Inspection Interfaces - Opens a shared development panel that displays cache, routes, mutations, queues, and custom state.
- Custom Debug Panels - Adds product-specific inspectors for feature flags, sync jobs, queues, or any custom state.
- Single-Point Devtool Mounts - Attaches a single lightweight devtools interface near the app root that works across multiple frameworks.
- Unified Debugging Shells - Opens a shared panel that aggregates inspectors for multiple libraries and custom product state.
- Route Lifecycle Handlers - Manages pending UI, errors, not-found states, and code splitting per route.
- Form Management - Headless UI form handling with TypeScript support.
- Forms - Listed in the “Forms” section of the Awesome React awesome list.
- Forms and Validation - Headless, type-safe form state management.
