Implements a React-like state resolver that handles both direct values and callback functions. The resolveHookState function intelligently detects whether a function expects arguments (using .length) and calls it with current state or without arguments accordingly. This pattern is reused across multiple hooks (useCounter, useGetSet, useMap, etc.) to support both setValue(newValue) and setValue(prev => next) APIs. The implementation is framework-agnostic and could be extracted for any React hook library.

A robust async function hook that manages loading/error/value states with built-in race condition prevention using call IDs. The hook tracks the last call ID and only updates state if the current call matches, preventing stale updates from resolving out of order. It also integrates with useMountedState to prevent updates on unmounted components. The discriminated union type for AsyncState provides excellent TypeScript inference. This pattern is reusable for any async operation management.

Factory function that creates a reducer-based context provider and hook, enabling shared state across components without prop drilling. Returns a tuple of [useReducerContext, ReducerProvider, context] following React's context patterns. The implementation properly handles the 'must be used inside provider' error case. This pattern is extracted and reusable for creating any context-based state management with reducers.

Abstracts event listener handling across different target types (DOM elements with addEventListener vs objects with on/off methods like socket.io). Uses type guards to detect the target interface and properly cleans up listeners. The implementation handles edge cases like null targets and JSON-stringifies options for dependency comparison. This abstraction is reusable for any library needing to work with multiple event target APIs.

A useState wrapper that batches updates using requestAnimationFrame, preventing layout thrashing from rapid state changes. Cancels pending animation frames before scheduling new ones and cleans up on unmount. This pattern is particularly useful for high-frequency updates like mouse movement or scroll position tracking. The implementation is self-contained and reusable for any state that updates faster than the browser can render.

Extends useEffect with custom dependency comparison, solving the common problem of object/array dependencies causing unnecessary re-renders. Takes a depsEqual function parameter and only triggers the effect when comparison fails. Includes development warnings for common misuses (no deps, all primitive deps). This pattern is the foundation for useDeepCompareEffect and useShallowCompareEffect, and is reusable for any effect that needs custom equality semantics.

Solves the stale closure problem in React by providing a getter function instead of raw state value. The get() function always returns the current state from a ref, while set() updates the ref and triggers re-render. This pattern is essential for callbacks that need access to latest state without being recreated. The implementation is minimal and reusable for any hook that needs to provide both current value access and update capability.

Creates a promise wrapper that prevents resolution/rejection after component unmount, solving the common 'setState on unmounted component' warning. Uses a ref to track mounted status and provides optional error handling for rejected promises after unmount. The implementation uses useMemo to create a stable wrapper function. This pattern is critical for any component that initiates async operations and needs safe cleanup.