---
title: Code Splitting
---
## Using `lazyRouteComponent`
Synchronous components are usually defined as functions and passed to the `route.component` option:
```tsx
function MyComponent() {
return
My Component
}
const route = new Route({
component: MyComponent,
})
```
But with TanStack Router, a route component can have a static `preload` method attached to it which will get called and awaited when the route is preloaded and/or loaded.
If we were to set this up manually **(don't do this)**, it would look something like this:
```tsx
const MyComponent = React.lazy(() => import('./MyComponent'))
MyComponent.preload = async () => {
await import('./MyComponent')
}
const route = new Route({
component: MyComponent,
})
```
This is a bit noisy and repetitive, so TanStack Router exports a `lazyRouteComponent` wrapper that you can use to simplify this process:
```tsx
import { lazyRouteComponent } from '@tanstack/react-router'
const route = new Route({
component: lazyRouteComponent(() => import('./MyComponent')),
})
```
The `lazyRouteComponent` wrapper not only implements `React.lazy()` under the hood, but automatically sets up the component with a preload method and promise management for you.
### Handling Named exports with `lazyRouteComponent`
The `lazyRouteComponent` wrapper also allows you to easily load components that are named exports from a module. To use this functionality, provide the name of the exported component as a second argument to the function:
```tsx
const route = new Route({
component: lazyRouteComponent(() => import('./MyComponent'), 'NamedExport'),
})
```
`lazyRouteComponent` is also type safe, to ensure that you are only able to provide valid named exports from the module, which helps prevent runtime errors.
## Data Loader Splitting
You may end up with a lot of data loaders that could potentially contribute to a large bundle size. If this is the case, you can code split your data loading logic using the Route's `loader` option. While this process makes it difficult to maintain type-safety with the parameters passed to your loader, you can always use the generic `LoaderContext` type to get most of the way there:
```tsx
import { LoaderContext } from '@tanstack/react-router'
const route = new Route({
path: '/my-route',
component: MyComponent,
loader: (...args) => import('./loader').then((d) => d.loader(...args)),
})
// In another file...
export const loader = async (context: LoaderContext) => {
/// ...
}
```
Again, this process can feel heavy-handed, so TanStack Router exports another utility called `lazyFn` which is very similar to `lazyRouteComponent` that can help simplify this process:
```tsx
import { lazyFn } from '@tanstack/react-router'
const route = new Route({
path: '/my-route',
component: MyComponent,
loader: lazyFn(() => import('./loader'), 'loader'),
})
// In another file...a
export const loader = async (context: LoaderContext) => {
/// ...
}
```
## Accessing Route APIs in Code Split Files with the `RouteApi` class
As you might have guessed, importing the very route that is already importing the code-split file you're in is a circular dependency, both in types and at runtime. To avoid this, TanStack Router exports a handy `RouteApi` class that you can use to access a route's type-safe APIs:
```tsx
import { Route } from '@tanstack/react-router'
const route = new Route({
path: '/my-route',
loader: () => ({
foo: 'bar',
}),
component: lazyRouteComponent(() => import('./my-component'), 'MyComponent'),
})
// In my-component.tsx
import { RouteApi } from '@tanstack/react-router'
const routeApi = new RouteApi({ id: '/my-route' })
export function MyComponent() {
const loaderData = routeApi.useLoaderData()
// ^? { foo: string }
return ...
}
```
The `RouteApi` class is also useful for accessing other type-safe APIs:
- `useLoaderData`
- `useMatch`
- `useParams`
- `useRouteContext`
- `useSearch`