Product
Introducing License Enforcement in Socket
Ensure open-source compliance with Socket’s License Enforcement Beta. Set up your License Policy and secure your software!
Valtio is a proxy-state library for React that makes it easy to manage and mutate state with a simple and intuitive API. It leverages JavaScript proxies to create reactive state objects that automatically trigger re-renders in your React components when the state changes.
Reactive State Management
Valtio allows you to create reactive state objects using the `proxy` function. The `useSnapshot` hook is used to subscribe to state changes and trigger re-renders in your React components.
const { proxy, useSnapshot } = require('valtio');
const state = proxy({ count: 0 });
function Counter() {
const snap = useSnapshot(state);
return (
<div>
<p>{snap.count}</p>
<button onClick={() => state.count++}>Increment</button>
</div>
);
}
Derived State
Valtio supports derived state using the `derive` function. This allows you to create computed properties that automatically update when the underlying state changes.
const { proxy, useSnapshot, derive } = require('valtio');
const state = proxy({ count: 0 });
derive({
doubleCount: (get) => get(state).count * 2
});
function Counter() {
const snap = useSnapshot(state);
return (
<div>
<p>{snap.count}</p>
<p>{snap.doubleCount}</p>
<button onClick={() => state.count++}>Increment</button>
</div>
);
}
Middleware
Valtio provides a `subscribe` function to listen for state changes and execute side effects. This is useful for logging, analytics, or other middleware-like functionalities.
const { proxy, subscribe } = require('valtio');
const state = proxy({ count: 0 });
subscribe(state, () => {
console.log('State changed:', state.count);
});
state.count++;
Zustand is a small, fast, and scalable bearbones state-management solution for React. It provides a simple API for creating global state and has a minimalistic approach compared to Valtio. While Valtio uses proxies for reactivity, Zustand uses hooks and selectors for state management.
MobX is a battle-tested library that makes state management simple and scalable by transparently applying functional reactive programming (TFRP). It uses observables to track state changes and automatically re-renders components. MobX is more feature-rich and has a steeper learning curve compared to Valtio.
Redux is a predictable state container for JavaScript apps, commonly used with React. It provides a centralized store and actions to manage state changes. Redux is more verbose and requires more boilerplate code compared to Valtio, but it is highly scalable and has a large ecosystem of middleware and developer tools.
npm i valtio
makes proxy-state simple
Valtio turns the object you pass it into a self-aware proxy.
import { proxy, useProxy } from 'valtio'
const state = proxy({ count: 0, text: 'hello' })
You can make changes to it in the same way you would to a normal js-object.
setInterval(() => {
++state.count
}, 1000)
Create a local snapshot that catches changes. Rule of thumb: read from snapshots, mutate the source. The component will only re-render when the parts of the state you access have changed, it is render-optimized.
function Counter() {
const snapshot = useProxy(state)
return (
<div>
{snapshot.count}
<button onClick={() => ++state.count}>+1</button>
</div>
)
}
You can access state outside of your components and subscribe to changes.
import { subscribe } from 'valtio'
// Suscribe to all state changes
const unsubscribe = subscribe(state, () => console.log('state has changed to', state))
// Unsubscribe by calling the result
unsubscribe()
You can also subscribe to a portion of state.
const state = proxy({ obj: { foo: 'bar' }, arr: ['hello'] })
subscribe(state.obj, () => console.log('state.obj has changed to', state.obj))
state.obj.foo = 'baz'
subscribe(state.arr, () => console.log('state.arr has changed to', state.arr))
state.arr.push('world')
To subscribe to a primitive value of state, consider subscribeKey in utils.
Valtio supports React-suspense and will throw promises that you access within a components render function. This eliminates all the async back-and-forth, you can access your data directly while the parent is responsible for fallback state and error handling.
const state = proxy({ post: fetch(url).then((res) => res.json()) })
function Post() {
const snapshot = useProxy(state)
return <div>{snapshot.post.title}</div>
}
function App() {
return (
<Suspense fallback={<span>waiting...</span>}>
<Post />
</Suspense>
)
}
See https://github.com/pmndrs/valtio/pull/62 for more information.
import { proxy, ref } from 'valtio'
const state = proxy({
count: 0,
dom: ref(document.body),
})
You can subscribe a component to state without causing render, just stick the subscribe function into useEffect.
function Foo() {
const ref = useRef(state.obj)
useEffect(() => subscribe(state.obj, () => ref.current = state.obj), [state.obj])
// ...
By default, state mutations are batched before triggering re-render. Sometimes, we want to disable the batching.
function TextBox() {
const snapshot = useProxy(state, { sync: true })
return <input value={snapshot.text} onChange={(e) => (state.text = e.target.value)} />
}
You can use Redux DevTools Extension for plain objects and arrays.
import { devtools } from 'valtio/utils'
const state = proxy({ count: 0, text: 'hello' })
const unsub = devtools(state, 'state name')
Valtio is not tied to React, you can use it in vanilla-js.
import { proxy, subscribe, snapshot } from 'valtio/vanilla'
const state = proxy({ count: 0, text: 'hello' })
subscribe(state, () => {
console.log('state is mutated')
const obj = snapshot(state) // A snapshot is an immutable object
})
You can use it locally in components. Notes
import { useLocalProxy } from 'valtio/utils'
function Foo() {
const [snapshot, state] = useLocalProxy({ count: 0, text: 'hello' })
FAQs
🧙 Valtio makes proxy-state simple for React and Vanilla
We found that valtio demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 2 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Product
Ensure open-source compliance with Socket’s License Enforcement Beta. Set up your License Policy and secure your software!
Product
We're launching a new set of license analysis and compliance features for analyzing, managing, and complying with licenses across a range of supported languages and ecosystems.
Product
We're excited to introduce Socket Optimize, a powerful CLI command to secure open source dependencies with tested, optimized package overrides.