Displaying 1 to 20 from 243 results

redux - Predictable state container for JavaScript apps

  •    Javascript

It helps you write applications that behave consistently, run in different environments (client, server, and native), and are easy to test. On top of that, it provides a great developer experience, such as live code editing combined with a time traveling debugger.You can use Redux together with React, or with any other view library. It is tiny (2kB, including dependencies).

freactal - Clean and robust state management for React and React-like libs.

  •    Javascript

freactal is a composable state management library for React.The library grew from the idea that state should be just as flexible as your React code; the state containers you build with freactal are just components, and you can compose them however you'd like. In this way, it attempts to address the often exponential relationship between application size and complexity in growing projects.

machina.js - js ex machina - finite state machines in JavaScript

  •    Javascript

Machina.js is a JavaScript framework for highly customizable finite state machines (FSMs). Many of the ideas for machina have been loosely inspired by the Erlang/OTP FSM behaviors. Finite state machines are a great conceptual model for many concerns facing developers – from conditional UI, connectivity monitoring & management to initialization and more. State machines can simplify tangled paths of asynchronous code, they're easy to test, and they inherently lend themselves to helping you avoid unexpected edge-case-state pitfalls. machina aims to give you the tools you need to model state machines in JavaScript, without being too prescriptive on the problem domain you're solving for.




unistore - 🌶 650b state container with component actions for Preact & React

  •    Javascript

A tiny ~650b centralized state container with component bindings for Preact & React. This project uses node and npm. Go check them out if you don't have them locally installed.

flow - Name UI states, navigate between them, remember where you've been.

  •    Java

Flow gives names to your Activity's UI states, navigates between them, and remembers where it's been. Navigate between UI states. Support the back button easily without confusing your users with surprising results. Remember the UI state, and its history, as you navigate and across configuration changes and process death. Manage resources with set-up/tear-down hooks invoked for each UI state. UI states can easily share resources, and they'll be disposed when no longer needed.

react-cursor - Immutable state for React.js

  •    Javascript

Cursors are a tool for working with recursive or deeply nested data, immutably. react-cursor is a javascript port of an abstraction that I first saw in ClojureScript. This implementation is decoupled from any rendering library and is very small. Cursors are useful in UI programming, because UIs are tree shaped and naturally have tree-shaped state. Cursors let your app hold all its state in one place at the root of the UI tree; thus the root is stateful, and all downtree views are stateless.


StatefulViewController - Placeholder views based on content, loading, error or empty states

  •    Swift

A protocol to enable UIViewControllers or UIViews to present placeholder views based on content, loading, error or empty states. As trivial as this flow may sound, there are a lot of cases that result in a rather large decision tree.

undux - ⚡️ Dead simple state management for React

  •    TypeScript

Be sure to define a key for each value in your model, even if the value is initially undefined. That's all there is to it.

unstated - State so simple, it goes without saying

  •    Javascript

For more examples, see the example/ directory. If you're like me, you're sick of all the ceremony around state management in React. Something that fits in well with the React way of thinking, but doesn't command some crazy architecture and methodology.

xstate - Functional, Stateless JS Finite State Machines and Statecharts

  •    TypeScript

Functional, stateless JavaScript finite state machines and statecharts. Statecharts are a formalism for modeling stateful, reactive systems. This is useful for declaratively describing the behavior of your application, from the individual components to the overall application logic.

reworm - the simplest way to manage state!

  •    TypeScript

Forget about actions, connections, reducers and a lot of boilerplate to create and manage states. With reworm you can create and manage state as simple as on the image above. Selectors are good because they prevent you from duplicating code. With it you can just create some functions and use them throughout your application.

react-values - A set of tiny React components for handling state with render props.

  •    Javascript

A set of tiny, composable React components for handling state with render props. It does this using a small render-prop-based API that exposes helpful transforms like toggle, increment, filter, etc. depending on the type of value, all based on JavaScripts native value types...

final-form - 🏁 Framework agnostic, high performance, subscription-based form state management

  •    Javascript

In the interest of making 🏁 Final Form the best library it can be, we'd love your thoughts and feedback. Take a quick survey.

freezer - A tree data structure that emits events on updates, even if the modification is triggered by one of the leaves, making it easier to think in a reactive way

  •    Javascript

A tree data structure that emits events on updates, even if the modification is emited by one of the leaves, making it easier to think in a reactive way. Are you looking for an immutable.js alternative? Freezer is made with React.js in mind and it uses real immutable structures. It is the perfect store for you application.

react-copy-write - ✍️ Immutable state with a mutable API

  •    Javascript

An immutable React state management library with a simple mutable API, memoized selectors, and structural sharing. Powered by Immer. Check out this small demo.

react-powerplug - :electric_plug: Renderless Containers

  •    Javascript

React PowerPlug is a set of pluggable renderless components and helpers that provides different types of state and logic utilities that you can use with your dumb components. It creates state and passes down the logic to the children, so you can handle your data. Read about the Render Props pattern.