<!--
Sitemap:
- [rxfy](/index): Typed, normalized, reactive state — built on RxJS
- [Comparison](/comparison): rxfy versus Redux Toolkit, MobX, Jotai, TanStack Query, and TanStack DB
- [Inspired by](/inspired-by): the libraries and ideas rxfy grew out of
- [Agent Skills](/agent-skills): Accurate rxfy context for AI coding assistants
- [Examples](/examples): Runnable apps, from client-only to fully synced
- [Changelog](/changelog)
- [Getting Started](/getting-started)
- [Create Store](/getting-started/create-store): Normalized reactive state in a client-only app
- [Add SSR](/getting-started/add-ssr): Render the first paint on the server, hydrate with no refetch
- [Add Sync Client](/getting-started/add-sync-client): The full stack: the server publishes, the client syncs
- [Core Concepts](/core-concepts): The ideas rxfy is built on
- [Observables](/core-concepts/observables): A value that changes over time, that you can subscribe to
- [Normalization](/core-concepts/normalization): Store each entity once, reference it by id
- [Late Unwrapping](/core-concepts/late-unwrapping): Unwrap async state at the leaf, not the trunk
- [Server-Side Rendering](/core-concepts/ssr): Dehydrate on the server, hydrate with no refetch
- [rxfy](/rxfy): The core package: atoms, lenses, models, and states
- [createModel](/rxfy/create-model): Typed entities in normalized storage
- [defineState](/rxfy/define-state): Typed, normalized state shapes with fetching and mutations
- [createAtom](/rxfy/create-atom): A reactive cell with synchronous get, set, and modify
- [createLens](/rxfy/create-lens): A two-way view into part of an Atom
- [React Bindings](/react): Hooks and helpers for using rxfy in React
- [useStateData](/react/use-state-data): Fetch, normalize, and subscribe to a query
- [useStatePagedData](/react/use-state-paged-data): Paginated and infinite-scroll lists
- [useModelStore](/react/use-model-store): Subscribe to one normalized entity by id
- [useAtom](/react/use-atom): Two-way binding for any IAtom
- [Pending](/react/pending): Render pending, rejected, and fulfilled UI for any observable
- [usePending](/react/use-pending): The status value behind Pending
- [useObservable](/react/use-observable): Bind a raw Observable to React
- [Sync Client in React](/react/sync-client): StoreProvider, useSyncClient, and update handles
- [rxfy-client](/framework/client): The framework-agnostic browser sync runtime
- [createSyncClient](/framework/client/create-sync-client): Connect a transport and drive the sync loop
- [readSsrGrants](/framework/client/read-ssr-grants): Lift SSR-embedded channel grants
- [rxfy-server](/framework/server): Bind Drizzle tables, write, and publish sync updates
- [defineResource](/framework/server/define-resource): Tie a Drizzle table to an rxfy model
- [createSync](/framework/server/create-server): Wire a storage adapter, hub, and secret into a Live object
- [createInMemoryHub](/framework/server/hub): The socket-keyed pub/sub backbone
- [Writes](/framework/server/writes): sync.create / sync.update / sync.delete and touch
- [Storage adapters](/framework/server/storage-adapters): Persist writes with Drizzle or in memory
- [Sync messages](/framework/server/messages): What travels between server and client
- [Grants](/framework/server/grants): The server signs what it serves; the client subscribes with the token
- [rxfy-ws](/framework/ws): The default WebSocket transport
- [createWsServer](/framework/ws/server): Attach a Hub to WebSocket connections
- [createWsClient](/framework/ws/client): The browser transport with reconnect and replay
- [Custom transports](/framework/ws/custom-transport): Bring your own ClientTransport
- [Guides](/guides): Task-focused walkthroughs of common rxfy patterns
- [Pagination and infinite scroll](/guides/pagination): Load and append pages into one normalized list
-->

# usePending \[The status value behind Pending]

The hook behind [`Pending`](/react/pending), for when you need the status value rather than
rendered UI. It subscribes to any `ObservableLike<T>` (an `Observable<T>` or a plain value) and
returns the current `IWrapped<T>`, narrowed to `PENDING` / `FULFILLED` /
`REJECTED`, never `IDLE`. Pass `getDefaultValue` to start `FULFILLED` instead of `PENDING`.

:::tip\[Prefer `Pending` for rendering]
To render UI per status, reach for the [`Pending`](/react/pending) component, not this hook — it
keeps the unwrap at the render edge ([late unwrapping](/core-concepts/late-unwrapping)) and holds
the last fulfilled value across a background reload. Use `usePending` only when you genuinely need
the `IWrapped<T>` value itself (e.g. a count or a derived label), not to gate a subtree.
:::

```tsx
import { usePending, useStateData } from "rxfy-react";
import { StatusEnum } from "rxfy";
import { fetchTodos, todosState } from "./todos";

function TodoCount({ params }: { params: object }) {
  const { data$ } = useStateData({ state: todosState, fetchFn: fetchTodos, params });
  const wrapped = usePending(data$);

  if (wrapped.type === StatusEnum.PENDING) return <span>…</span>;
  if (wrapped.type === StatusEnum.REJECTED) return <span>error</span>;
  return <span>{wrapped.value.todos.length} todos</span>;
}
```

```ts
function usePending<T>(
  source$: ObservableLike<T>,
  getDefaultValue?: () => T,
): IWrapped<T, StatusEnum.PENDING | StatusEnum.FULFILLED | StatusEnum.REJECTED>;

type ObservableLike<T> = Observable<T> | T;
```

The `IWrapped<T, K>` it returns is the async-status discriminated union, narrowed
to the `K` cases:

```ts
type IWrapped<T, K extends StatusEnum = StatusEnum> = {
  [StatusEnum.IDLE]: { type: StatusEnum.IDLE };
  [StatusEnum.PENDING]: { type: StatusEnum.PENDING };
  [StatusEnum.FULFILLED]: { type: StatusEnum.FULFILLED; value: T };
  [StatusEnum.REJECTED]: { type: StatusEnum.REJECTED; error: unknown };
}[K] & { type: K };
```

The matching `createIdle` / `createPending` / `createFulfilled` / `createRejected`
constructors are exported from `rxfy` for building these values directly.

:::warning
`source$` must be referentially stable across renders; wrap inline-created sources in
`useMemo`.
:::
