Reduxless

> A small and performant state management and routing library with unidirectional data flow.

  

Looking for the API? Click here

Introduction

Reduxless simplifies some of the complexity of Redux and reduces the amount of necessary boilerplate code. It is also much more performant and scales linearly as the application's state grows (see perfomance analysis).

Reduxless combines the roles of reducers and actions into one operation: the two key operations are actions and selectors. We lose the ability to perform time travelling on our state, but the advantages of simpler and faster code can outweigh that benefit.

Installation

To install the stable version:
``
npm install --save reduxless
`

Importing

Reduxless can be used with any React-like library.

To include it in a Preact project:
`js
import reduxless from 'reduxless/preact'
`

And for a React based projects:
`js
import reduxless from 'reduxless/react'
`

Alternatively if you are using a library other than React or Preact, for example, inferno, you can inject the module into Reduxless like so:
`js
import createReduxless from "reduxless";

const reduxless = createReduxless(require("inferno"));
`




The general gist

The following snippet of code demonstrates how reduxless can be used with a React-like library -- in this case Preact:

`jsx
import { h, render } from 'preact';
import { createStore, Container, mapper } from 'reduxless/preact';

const store = createStore({ name: 'Bart Simpson' });

const Component = ({name, updateName}) => (


() => updateName(name == 'Bart Simpson' ? 'Lisa Simpson' : 'Bart Simpson')
}>
Hello there, {name}! Click to change me.


);

const MappedComponent = mapper(
{
// selectors
name: store => store.get('name')
},
{
// actions
updateName: (store, ownProps, newName) => store.set('name', newName)
}
)(Component);

render(



)
`

The Container component provides the store to all of it's nested children components via context. Its use is optional and you can pass the store down manually if you prefer, for example:

`jsx
render(

)
`

The mapper function is a performance convenience helper. It uses the given selectors to determine whether the mapped component should be rendered by doing shallow ref comparisons. This means it is important to create new objects when updating the store; otherwise, your components won't be updated. The actions are automatically injected with the store and the mapped component's props.

Routing and browser history syncing


Reduxless offers a straightforward mechanism for both routing (i.e. which components to render based on the URL) and keeping the browser URL and store state in sync. You can choose which properties in the store will trigger a pushState event and also whether the popstate event from the browser history navigation will update the store.

In the example above if we wanted the name property synced, it would be as simple as:

`js
import { createStore, enableHistory } from 'reduxless/preact';

const store = createStore({ name: 'Bart Simpson' });
enableHistory(
this.store,
['name']
);
`

Routing is as straightforward as:

`jsx
import { h } from "preact";
import { Match, Link } from "reduxless/preact";

const store = createStore({ name: 'Bart Simpson' });

enableHistory(
this.store,
['name']
);

const app = () => (



• 
  Todos
  


• 
  Counters
  









);
`

The documentation section below describes the API in more detail, including configuration details for using hash; how to validate the data from the URL; and controlling one-way or two-way binding between the store state and browser URL.

Documentation

- API
- [createStore([initialState])](https://dhassaine.github.io/reduxless/store)
- , mapper() for the react bindings.
- enableHistory() for the browser history sync functionality.
- , for the navigational components.
- selectorMemoizer(selectors, projectionFunction)` for improving rendering performance by wrapping your selectors with a memoizer.

Differences to Redux

The state is not one nested object but multiple objects. This means libraries like reselect won't work as expected. Redux is expected to be given a new object for each reducer. Libraries like ImmutableJS can help with making modifications to the state as efficient as possible, but ultimately recreating an object with many properties just to get a new reference is expensive. Another bottleneck with Redux is that every reducer has to run when an action is dispatched. See perfomance analysis for further details.

Change Log

This project follows semantic versioning.

LICENSE

MIT