streamich/react-use

Features

• Browser APIs - Provides a comprehensive set of hooks that wrap various native browser APIs for easy integration into React components.
• React Hooks - Offers a comprehensive collection of reusable hooks for managing common state patterns in React applications.
• List State Hooks - Ships hooks for managing list-based state including adding, removing, updating, and clearing items.
• User Interaction - Implements utilities to monitor keyboard inputs, mouse movements, and touch gestures for responsive interfaces.
• Browser Sensor Monitoring - Includes a suite of hooks for monitoring device sensors such as battery status, geolocation, and motion.
• Hook-Based Logic Encapsulations - Wraps complex logic and browser API interactions into reusable hooks that manage their own lifecycles.
• Reactive Array State - Provides specialized hooks for tracking arrays with stable methods to modify lists and trigger re-renders.
• Generic - Enables updating and retrieving state using custom methods or specialized update functions.
• Promise-Based State Resolution - Integrates asynchronous promises into the state model to track pending, completed, or failed execution states.
• Browser API Hooks - Provides a consistent hook-based interface for interacting with native browser APIs and hardware sensors.
• DOM Interaction Hooks - Includes a toolkit for tracking element dimensions, visibility, and user input gestures in the browser.
• Async Loading State Handlers - Provides handlers to track the loading status, errors, and resulting data of promise-based functions.
• React State Primitives - Implements complex state patterns including counters, lists, and local storage synchronization via hooks.
• Side Effect Synchronization - Coordinates the execution of browser API actions in response to state changes to sync with external environments.
• Boolean State Primitives - Ships a boolean state hook with a convenient function to flip the current state.
• Session Storage Synchronization - Provides a hook to synchronize application state with browser session storage for persistence across refreshes.
• Deep Equality Checks - Implements recursive structural equality checks for hook dependencies to optimize effect triggering.
• Browser Storage Persistence - Implements synchronization between React state and browser local storage with custom serialization.
• Unordered Unique Collection Management - Deno-inspired tracking of a set of unique values with methods to add, remove, toggle, and clear.
• State Counters - Deno-inspired maintenance of a numeric value with the ability to increment, decrement, and reset.
• Interval-Based Task Execution - Runs functions on fixed timetables or harmonic intervals using background timers.
• Animation Execution Controllers - Enables component rendering synchronized with animation frames, intervals, and timeouts using interpolation.
• Timer Schedulers - Provides interfaces for scheduling tasks with timeouts, including methods to cancel or reset them.
• Timer Lifecycle Managers - Encapsulates interval and timeout IDs within hooks to coordinate scheduling and automatic cancellation.
• Async Operation Coordinators - Coordinates asynchronous function execution through debouncing, throttling, and error dispatching.
• Custom Comparison Logic - Provides a way to trigger side effects using custom or shallow comparison logic instead of reference equality.
• Debouncing Utilities - Provides utilities to delay function execution until a period of inactivity has passed.
• Deep Equality Comparison - Enables triggering effects only when the deeply nested values of a dependency change.
• Delayed Execution Utilities - Triggers functions after a set duration with integrated cancellation and reset capabilities.
• Memoization Hooks - Ships hooks that cache the results of expensive calculations to optimize frontend performance.
• Global State Managers - Creates shared state instances accessible by multiple components regardless of their position in the tree.
• State Context Generators - Provides utilities for creating shared state contexts and reducer factories for global data management.
• Object State Trackers - Deno-inspired tracking of a key-value object with methods to update or remove individual entries.
• Throttling Utilities - Provides hooks to limit the number of times a function can be executed within a time window.
• State Update Schedulers - Provides hooks to schedule state updates during the browser's next animation frame for smoother visual transitions.
• Frame Callbacks - Implements callbacks that synchronize function execution with the browser's native animation frames.
• Animation Interpolators - Provides calculation of intermediate numerical values over time to create smooth visual transitions.
• Animation Loops - Provides hooks to execute functions on every animation frame for smooth visual transitions.
• Physics and Motion Dynamics - Handles periodic updates and numeric interpolations using spring dynamics for natural movement.
• Physics-Based Animations - Implements physics-based numeric animations using spring dynamics for fluid motion.
• Frame-Synchronized Interpolators - Uses the browser's native refresh cycle to calculate and update numeric values for smooth animations.
• React Animation Workflows - Enables smooth visual transitions and physics-based motion using animation frames and numeric interpolation.
• DOM Observation Utilities - Provides declarative wrappers for IntersectionObserver and ResizeObserver to track element visibility and size.
• Dynamic Styling Utilities - Deno-inspired updating of style rules dynamically while supporting media queries and pseudo-selectors.
• Element Scroll Trackers - Deno-inspired triggering of a re-render whenever the scroll position of a specific element changes.
• Window Lifecycle Monitors - Tracks browser window dimensions and provides callbacks when the window is resized.
• Keyboard Input Listeners - Deno-inspired monitoring of keyboard input and triggering a state change when a specific key is pressed.
• Drag and Drop Interactions - Deno-inspired detection and processing of files, URIs, or text dropped onto a specific element or page.
• Hover State Trackers - Deno-inspired monitoring of whether a mouse cursor is positioned over a specific element.
• Input Combination Detection - Deno-inspired monitoring of keyboard input to identify simultaneous or sequential key presses.
• Layout Observers - Deno-inspired tracking of HTML element dimensions, scroll positions, and intersection status.
• Component Lifecycle Management - Imitates class component lifecycle patterns to control logic during mount, update, and unmount phases.
• Viewport Threshold Tracking - Deno-inspired tracking of current window width and returning a label based on pixel thresholds.
• Scroll Interaction Handlers - Provides hooks to track whether a user is currently scrolling and update the application state.
• Scroll Locking - Deno-inspired prevention of the body element from scrolling when modals or overlays are active.
• Media Query Observers - Deno-inspired tracking of the state of CSS media queries in real-time.
• Timing Hooks - Ships utilities for managing timing logic, including intervals, timeouts, and numeric interpolations.
• Typing Detectors - Triggers a callback immediately when a user begins typing to enable responsive UI reactions.
• User Idleness Detectors - Tracks user activity on a page and triggers a state change when the user becomes idle.
• User Interaction Patterns - Implements behavioral patterns for detecting and tracking user inactivity over a specified duration.
• Element Dimension Tracking - Deno-inspired monitoring of the width and height of an HTML element with updates on size change.
• Viewport Visibility Observers - Deno-inspired monitoring of when a target element enters or leaves the viewport using an intersection observer.
• Viewport Size Trackers - Monitors browser window dimensions and updates state automatically when the viewport resizes.
• State Reference Capture - Provides a way to track the current value of props or state in a reference for use in asynchronous callbacks.
• Browser Storage - Ships a unified interface to manage data across cookies, local storage, and session storage.
• Browser Cookie Management - Provides a comprehensive hook for reading, writing, and deleting browser cookies.
• Event Listener Management - Manages the attachment and detachment of DOM and window event listeners to prevent memory leaks.
• Mount-Skipping Schedulers - Allows execution of side effects on updates while skipping the first invocation during mount.
• Mount-Only Effect Execution - Allows for the execution of a side effect exactly one time during the initial component mount.
• Mutable Ref Storages - Stores mutable values in references to provide async callbacks with current state without triggering re-renders.
• Reducer State Management - Deno-inspired management of complex state transitions by mapping updating functions to callable methods.
• Shared Reducer Contexts - Deno-inspired sharing of a reducer-based state across components via a context provider and dispatched actions.
• Isomorphic Effect Wrappers - Allows running layout effects without triggering server-side rendering warnings by adapting to the environment.
• Mounted Component Guards - Provides a mechanism to ensure asynchronous callbacks only execute if the component remains mounted.
• Lifecycle Optimization - Provides hooks to manage component mount/unmount tasks and control render cycles for better performance.
• Side Effect Management Libraries - Provides a set of hooks to manage browser-specific side effects like clipboard access and document title updates.
• Custom Comparison Triggers - Enables triggering side effects based on a custom comparison function instead of reference equality.
• Deep Comparison Triggers - Executes side effects only when values within a dependency array change deeply.
• Shallow Comparison Triggers - Implements side effect execution that triggers only when dependencies change based on a shallow comparison.
• Previous Value Tracking - Deno-inspired retention of the value of a state or prop from the previous render cycle for comparison.
• Debounced State Updates - Restricts the frequency of state updates by delaying changes until a specified interval has passed.
• Browser & DOM Utilities - Collection of essential browser hooks.
• Hook Extensions - Comprehensive library of essential, ready-to-use hook utilities.

Star history