react-redux-formal

Long name, I know. But the name is supposed to convey that it's build on top of both react and redux.

Formal came into life after I experimented with redux-form but found it a bit too "heavy" for most usecases I required. It came with slightly too much out of the box so I decided to make a more lightweight alternative.

Installation

As you'd expect, react-redux-formal is available on npm.

$ npm install --save react-redux-formal

As the name would suggest, react-redux-formal depends on redux as well as react-redux, so you might need to issue

$ npm install --save redux react-redux

Setup

After you've installed the package, you'll need to add the formReducer to your store and expose the store to your app through react-redux's Provider.

Note: react-redux-formal requires the formReducer to be mounted at state.form.

import { Provider } from 'react-redux';
import { formReducer } from 'react-redux-formal';
import { render } from 'react-dom';
import { combineReducers, createStore } from 'redux';
 
const store = createStore(combineReducers({
  form: formReducer,
}));
 
render((
  <Provider store={store}>
    <App />
  </Provider>
), document.getElementById('app-container')):

Usage

With the reducer in place you can use the connectForm function to hook your app up and have fields injected. For example, a simple login form component might look something like this:

import PropTypes from 'prop-types';
import React from 'react';
import { connectForm, validators } from 'react-redux-formal';
 
export class Signup extends React.Component {
    static propTypes = {
        fields: PropTypes.object.isRequired,
        formValidate: PropTypes.func.isRequired,
        getValues: PropTypes.func.isRequired,
    }
 
    constructor() {
        super();
 
        this.onSubmit = this.onSubmit.bind(this);
    }
 
    onSubmit(ev) {
        ev.preventDefault();
 
        this.props.formValidate()
            .then(values => {
                /* do stuff with values */
            })
            .catch(() => {});
    }
 
    render() {
        const { fields } = this.props;
 
        return (
            <form onSubmit={this.onSubmit}>
                <fields.username />
                <fields.email />
                <fields.password />
 
                <button type="submit">Sign up</button>
            </form>
        );
    }
}
 
export default connectForm(() => {
    name: 'signup',
    fields: {
        username: {
            type: 'text',
            label: 'Username',
            validators: [
                validators.required('Username is required'),
            ],
        },
        email: {
            type: 'text',
            label: 'E-mail',
            validators: [
                validators.required('E-mail is required'),
            ],
        },
        password: {
            type: 'text',
            label: 'Password',
            validators: [
                validators.required('Password is required'),
            ],
        },
    },
})(Signup);

API

`connectForm(mapStateToOptions)(component)`

Generate fields that are injected into the wrapped component. Does not modify the component passed to it. Instead it returns a new component which wraps the original component which should be used instead.

mapStateToOptions (Function): A function which should return an object with options for your form. This gets passed the same arguments as redux connect's mapStateToProps. The return options object can have the following keys:
- name (String): Name of the form, this is used to store the form in redux under its own namespace. Ensure this is unique for each form.
- fields (Object): Object containing field specifications. The key will be reused when injecting fields into your component.
- [values] (Object): Initial values to populate the fields with.
- [inputTypes] (Object): Custom input types. This can be used to specify your own input types if you don't want to use the ones provided.
component (Component): The component to wrap.