npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner

react-fieldset

v4.0.0

Published

Declarative field naming and props providing in complex tree-data forms

Downloads

166

Readme

React Fieldset

Declarative field naming and props providing in complex tree-data forms.

What & Why

Naming and providing props to Form components may be quite tedious for large and deeply nested data. Also it's difficult to maintain, if your form changes frequently.

It would be great to use a <Fieldset/> component that will:

  • Simulate data tree and deal with field naming
  • Provide context to child components (Field, ErrorMessage, Custom Components, etc.)
  • Make code easier
  • Not be attached to specific form library, and can be used with different libraries

Make sure you need it!

Fieldset uses react contex and this can affect performance, so make sure your data and fields tree is really so complex that you need a <Fieldset/>. Anyway, try not to use it at first.

✅   You may need it if:

  • You really need a declarative way to create complex forms with nested data
  • You need to speed up development. For example, to build MVP
  • The layout of your form is complex and the fields may not be direct children of the parent and you need to provide them with props

🚫   You don't need it if:

  • Using render-prop pattern can solve your nesting
  • You know that your form usually does not change. In this case, it is better to build it once without <Fieldset/>
  • Your data and layout are as simple as the code block examples in this readme

⚡  Also, since <Fieldset/> provides its context for all connected child components, so avoid passing not memoized functions and objects to Fieldset props whenever possible. <Fieldset/> using React.memo for memoize context, and this will cause each of connected child components to be re-rendered every time Form's context changes.

Usage

import Fieldset, { withFieldset, useFieldset } from 'react-fieldset'

All code sections are written in Formik style, but Fieldset isn't really attached with it and can be used with different libraries.

Form data layering

It means to accumulate name-prefix for nested fields in a form data. For example:

//This code
<Field name="social.facebook" />
<Field name="social.twitter" />

//May look like this
<Fieldset name="social">
  <Field name="facebook" />
  <Field name="twitter" />
</Fieldset>

It also works fine to Arrays and Deep nested fields:

//Array
friends.map((friend, index) => (
<Fieldset key={index} name={`friends.${index}`}>
  <Field name="name"/>
  <Field name="age"/>
</Fieldset>

//Deep nested
<Fieldset name='level1'>
  <Field name='nested-value'/>
  <Fieldset name='level2'>
    <Field name='deep-nested-value'/>
  </Fieldset>
</Fieldset>

It also works fine with ErrorMessage, FastField, or any Custom Components - just connect them withFieldset() or using useFieldset. You can find more information about this below.

Providing props to the form components

All props (except name) will be provided directly to connected component. Also, feel free to use Fieldset both with or without name prop. So, for example, Fieldset can set "required" for all Fields components in one line:

//This code
<Field name="facebook" required={true}/>
<Field name="twitter" required={true}/>

//May look like this
<Fieldset required={true}>
  <Field name="facebook"/>
  <Field name="twitter"/>
</Fieldset>

Examples

Easy Array

This is a small illustration that shows how you can use Fieldset to create your own custom components like EasyArray, which can greatly simplify your code. Let's imagine that he needs to display this data structure:

const data = {
  array: [
    {
      id: 'firstNestedArray',
      nestedArray: [
        { id: 1, foo: 1, boo: 2 },
        { id: 2, foo: 3, boo: 4 },
      ],
    },
    {
      id: 'secondNestedArray',
      nestedArray: [
        { id: 3, foo: 5, boo: 6 },
        { id: 4, foo: 7, boo: 8 },
      ],
    },
  ],
}

Commonly this can be done with:

const UsualForm = ({ values }) => (
  <Form>
    {values.array.map((item, index) =>
      item.nestedArray.map((nestedItem, nestedIndex) => (
        <Fragment key={nestedItem.id}>
          <Field name={`array[${index}]nestedArray[${nestedIndex}].foo`} />
          <Field name={`array[${index}]nestedArray[${nestedIndex}].boo`} />
          <br />
        </Fragment>
      ))
    )}
  </Form>
)

But with EasyArray its looks more simpler:

const FormWithEasyArray = () => (
  <Form>
    <EasyArray name='array'>
      <EasyArray name='nestedArray'>
        <Field name='foo' />
        <Field name='boo' />
      </EasyArray>
    </EasyArray>
  </Form>
)

As working on EasyArray is also quite simple:

import Fieldset, { withFieldset, useFieldset } from 'react-fieldset'

const EasyArray = ({ name, keyProp = 'id', children, ...props }) => {
  const { fullName, fieldsetProps } = useFieldset(name)
  const [{ value }] = useField(fullName)

  return value.map((item, index) => (
    <Fieldset {...fieldsetProps} {...props} key={item[keyProp]} name={`${name}[${index}]`}>
      {children}
    </Fieldset>
  ))
}

export default EasyArray

// Don't forget to connect your Fields
export const Field = withFieldset(_Field)

Connection

To use <Fieldset/> you need to connect all components witch need to receive context. If you use <Field component={CustomInputComponent}> you need to connect <Field>, not <CustomInputComponent>.

You can connect components using withFieldset:

import { withFieldset } from 'react-fieldset'
export Field = withFieldset(_Field)
export ErrorMessage = withFieldset(_ErrorMessage)

Or, you can connect component using useFieldset hook:

import { useFieldset } from 'react-fieldset'

export const Field = props => {
  const { fullName, fieldsetProps, contextName } = useFieldset(props.name)
  return <_Field {...fieldsetProps} {...props} name={fullName} />
}