Skip to main content

class Snapshot

A Snapshot object represents an immutable snapshot of the state of Recoil atoms. It is intended to standardize the API for observing, inspecting, and managing global Recoil state. It is mostly useful for dev tools, global state synchronization, history navigation, etc.

class Snapshot {
// Accessors to inspect snapshot state
getLoadable: <T>(RecoilValue<T>) => Loadable<T>;
getPromise: <T>(RecoilValue<T>) => Promise<T>;
// API to transform snapshots for transactions
map: (MutableSnapshot => void) => Snapshot;
asyncMap: (MutableSnapshot => Promise<void>) => Promise<Snapshot>;
// Developer Tools API
getID: () => SnapshotID;
getNodes_UNSTABLE: ({
isModified?: boolean,
} | void) => Iterable<RecoilValue<mixed>>;
getInfo_UNSTABLE: <T>(RecoilValue<T>) => {...};
}
function snapshot_UNSTABLE(initializeState?: (MutableSnapshot => void)): Snapshot

Obtaining Snapshots#

Hooks#

Recoil provides the following hooks for obtaining snapshots based on the current state:

Building a Snapshot#

You can also build a fresh snapshot using the snapshot_UNSTABLE() factory, which accepts an optional initializer function. This can be used for testing or evaluating selectors outside of a React context.

Reading Snapshots#

Snapshots are read-only with respect to atom state. They can be used to read atom state and evaluate selectors' derived state. getLoadable() provides a Loadable with the state of the atom or selector in this Snapshot. The getPromise() method can be used to wait for the evaluated value of asynchronous selectors, so you can see what the value would be based on the static atom state.

Example#

function MyComponent() {
const logState = useRecoilCallback(({snapshot}) => () => {
console.log("State: ", snapshot.getLoadable(myAtom).contents);
const newSnapshot = snapshot.map(({set}) => set(myAtom, 42));
});
}

Transforming Snapshots#

There are cases where you may wish to mutate a snapshot. While snapshots are immutable, they have methods to map themselves with a set of transformations to a new immutable snapshot. The map methods take a callback that is passed a MutableSnapshot, which is mutated throughout the callback and will ultimately become the new snapshot returned by the mapping operation.

class MutableSnapshot {
set: <T>(RecoilState<T>, T | DefaultValue | (T => T | DefaultValue)) => void;
reset: <T>(RecoilState<T>) => void;
}

Notice that set() and reset() have the same signature as callbacks provided to a writeable selector's set property, but they only effect the new snapshot, not the current state.

Going to a Snapshot#

The following hook can be used for navigating the current Recoil state to the provided Snapshot:

Developer Tools#

Snapshots provide some methods useful for building developer tools or debugging capabilities with Recoil. This API is still evolving, and thus marked as _UNSTABLE, as we work on the initial dev tools.

Snapshot IDs#

Each committed state or mutated Snapshot has a unique opaque version ID that can be obtained via getID(). This can be used to detect when we have gone back to a previous snapshot via useGotoRecoilSnapshot().

Enumerate Atoms and Selectors#

The getNodes_UNSTABLE() method can be used to iterate all atoms and selectors that were in use for this snapshot. Atoms, selectors, and families may be created at any time. However, they will only show up in the snapshot if they are actually used. Atoms and selectors may be removed from subsequent state snapshots if they are no longer being used.

An optional isModified flag may be specified to only return atoms which have been modified since the last transaction.

Debug information#

The getInfo_UNSTABLE() method provides additional debug information for atoms and selectors. The debug information provided is evolving, but may include:

  • loadable - A Loadable with the current state. Unlike methods like getLoadable(), this method will not mutate the snapshot at all. It provides the current state and will not initialize new atoms/selectors, perform any new selector evaluations, or update any dependencies or subscriptions.
  • isSet - True if this is an atom with an explicit value stored in the snapshot state. False if this is a selector or using the default atom state.
  • isModified - True if this is an atom which was modified since the last transaction.
  • type - Either an atom or selector
  • deps - An iterator over the atoms or selectors this node depends on.
  • subscribers - Information about what is subscribing to this node for this snapshot. Details under development.

This is similar to the useGetRecoilValueInfo_UNSTABLE() hook, but provides information based on the state in the Snapshot instead of the current state. It cannot provide information not associated with a snapshot of Recoil state, such as subscribing React components.

State Initialization#

The <RecoilRoot> component and snapshot_UNSTABLE() factory take an optional initializeState prop for initializing the state via a MutableSnapshot. This can be helpful for loading persisted state when you know all atoms in advance and is compatible with server-side rendering where the state should be setup synchronously with the initial render. For per-atom initialization/persistence and ease of working with dynamic atoms, consider atom effects

function MyApp() {
function initializeState({set}) {
set(myAtom, 'foo');
}
return (
<RecoilRoot initializeState={initializeState}>
...
</RecoilRoot>
);
}