rc-form

What is rc-form?

The rc-form package is a form management library for React. It provides a set of utilities to manage form state, validation, and submission, making it easier to handle complex forms in React applications.

What are rc-form's main functionalities?

Form Creation

This feature allows you to create forms with validation rules. The `createForm` function is used to wrap the form component, and `getFieldDecorator` is used to register form fields with validation rules.

```jsx
import React from 'react';
import { createForm } from 'rc-form';

class MyForm extends React.Component {
  handleSubmit = () => {
    this.props.form.validateFields((err, values) => {
      if (!err) {
        console.log('Received values of form: ', values);
      }
    });
  };

  render() {
    const { getFieldDecorator } = this.props.form;
    return (
      <form onSubmit={this.handleSubmit}>
        <div>
          {getFieldDecorator('username', {
            rules: [{ required: true, message: 'Please input your username!' }],
          })(<input type="text" placeholder="Username" />)}
        </div>
        <button type="submit">Submit</button>
      </form>
    );
  }
}

export default createForm()(MyForm);
```

Field Validation

This feature allows you to add validation rules to form fields. In this example, the email field is validated to ensure it is a valid email address and is required.

```jsx
import React from 'react';
import { createForm } from 'rc-form';

class MyForm extends React.Component {
  handleSubmit = () => {
    this.props.form.validateFields((err, values) => {
      if (!err) {
        console.log('Received values of form: ', values);
      }
    });
  };

  render() {
    const { getFieldDecorator } = this.props.form;
    return (
      <form onSubmit={this.handleSubmit}>
        <div>
          {getFieldDecorator('email', {
            rules: [
              { type: 'email', message: 'The input is not valid E-mail!' },
              { required: true, message: 'Please input your E-mail!' }
            ],
          })(<input type="email" placeholder="Email" />)}
        </div>
        <button type="submit">Submit</button>
      </form>
    );
  }
}

export default createForm()(MyForm);
```

Dynamic Form Fields

This feature allows you to dynamically add form fields. The `addField` method updates the state to add new fields, and `getFieldDecorator` is used to register these fields with validation rules.

```jsx
import React from 'react';
import { createForm } from 'rc-form';

class DynamicForm extends React.Component {
  state = { keys: [] };

  addField = () => {
    const { keys } = this.state;
    this.setState({ keys: keys.concat(keys.length) });
  };

  handleSubmit = () => {
    this.props.form.validateFields((err, values) => {
      if (!err) {
        console.log('Received values of form: ', values);
      }
    });
  };

  render() {
    const { getFieldDecorator } = this.props.form;
    const { keys } = this.state;
    return (
      <form onSubmit={this.handleSubmit}>
        {keys.map(k => (
          <div key={k}>
            {getFieldDecorator(`field-${k}`, {
              rules: [{ required: true, message: 'Please input a value!' }],
            })(<input type="text" placeholder="Dynamic Field" />)}
          </div>
        ))}
        <button type="button" onClick={this.addField}>Add Field</button>
        <button type="submit">Submit</button>
      </form>
    );
  }
}

export default createForm()(DynamicForm);
```

Other packages similar to rc-form

formik

Formik is a popular form management library for React. It provides a set of tools to handle form state, validation, and submission. Compared to rc-form, Formik offers a more modern API and better integration with React hooks.

react-hook-form

React Hook Form is a performant, flexible, and extensible form library for React. It leverages React hooks to manage form state and validation. It is known for its minimal re-renders and easy integration with existing components, making it a strong alternative to rc-form.

redux-form

Redux Form is a library that integrates form state management with Redux. It allows you to manage form state in a centralized Redux store. While it offers powerful features, it can be more complex to set up compared to rc-form.

README

rc-form

React High Order Form Component.

Note: This is unstable, under development now.

Development

npm install
npm start

Example

http://localhost:8000/examples/

online example: http://react-component.github.io/form/examples/

Feature

• support reactjs and even react-native

install

Usage

import { createForm } from 'rc-form';

@createForm()
class Form extends React.Component {
  submit = () => {
    this.props.form.validateFields((error, value) => {
      console.log(error, value);
    });
  }

  render() {
    let errors;
    const {getFieldProps, getFieldError} = this.props.form;
    return (<div>
      <input {...getFieldProps('normal')}/>
      <input {...getFieldProps('required', {
        rules: [{required: true}],
      })}/>
      {(errors = getFieldError('required')) ? errors.join(',') : null}
      <button onClick={this.submit}>submit</button>
    </div>)
  }
}

createForm(formOption): Function

formOption.onFieldsChange(props, fields)

Called when field changed, you can dispatch fields to redux store.

formOption.mapPropsToFields(props)

convert value from props to fields. used for read fields from redux store.

createForm() will return another function:

function(WrappedComponent: React.Component): React.Component

Will pass a object as prop form with the following members to WrappedComponent:

getFieldProps(name, option): Object

Will create props which can be set on a input/InputComponent which support value and onChange interface.

After set, this will create a binding with this input.

name: String

This input's unique name.

option.valuePropName: String

Prop name of component's value field, eg: checkbox should be set ti checked ...

option.initialValue

Initial value of current component.

option.normalize(value, prevValue, allValues)

Return normalized value

option.trigger: String

Defaults to onChange. Event which is listened to collect form data.

option.validate: Object[]

option.validate[n].trigger: String|String[]

Event which is listened to validate. Defaults to onChange, set to falsy to only validate when call props.validateFields.

option.validate[n].rules: Object[]

Validator rules. see: async-validator

option.validateTrigger && option.rules

{
  validateTrigger: 'onBlur',
  rules: [{required: true}],
}
// is the shorthand of
{
  validate: [{
    trigger: 'onBlur',
    rules: [required: true],
  }],
}

option.validateFirst: Boolean

Defaults to false. whether stop validate on first rule of error for this field.

getFieldsValue([fieldNames: String[]])

Get fields value by fieldNames.

getFieldValue(fieldName: String)

Get field value by fieldName.

setFieldsValue(obj: Object)

Set fields value by kv object.

setFields(obj: Object)

Set fields by kv object. each field can contain errors and value member.

validateFields([fieldNames: String[]], [options: Object], callback: Function(errors, values))

Validate and get fields value by fieldNames.

options is the same as validate method of async-validator. add a new force member.

options.force: Boolean

Defaults to false. Whether to validate fields which have been validated(caused by validateTrigger).

getFieldError(name): String[]

Get input's validate errors.

isFieldValidating(name): Bool

Whether this input is validating.

resetFields([names: String[]])

Reset specified inputs. Defaults to all.

Test Case

http://localhost:8000/tests/runner.html?coverage

Coverage

http://localhost:8000/node_modules/node-jscover/lib/front-end/jscoverage.html?w=http://localhost:8000/tests/runner.html?coverage

License

rc-form is released under the MIT license.