@jsonforms/react vs formik vs react-final-form vs react-hook-form vs react-jsonschema-form vs uniforms
React Form Libraries
Search packages..
@jsonforms/reactformikreact-final-formreact-hook-formreact-jsonschema-formuniformsSimilar Packages:

React Form Libraries

React form libraries provide tools and components to help developers create, manage, and validate forms in React applications. These libraries offer various features such as state management, validation, and integration with UI frameworks, making it easier to handle user input and form submission. They help streamline the development process, improve code readability, and enhance the user experience by providing efficient and scalable solutions for form handling in React applications.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
@jsonforms/react02,737285 kB1503 months agoMIT
formik034,327585 kB84010 months agoApache-2.0
react-final-form07,439263 kB3784 months agoMIT
react-hook-form044,8481.22 MB107 days agoMIT
react-jsonschema-form015,889-1487 years agoApache-2.0
uniforms02,103224 kB302 years agoMIT

Feature Comparison: @jsonforms/react vs formik vs react-final-form vs react-hook-form vs react-jsonschema-form vs uniforms

Schema Support

  • @jsonforms/react:

    @jsonforms/react provides comprehensive support for JSON Schema, allowing for the creation of complex and nested forms based on schema definitions. It supports all standard JSON Schema features, including validation, default values, and custom formats. The library is designed to be highly extensible, enabling developers to create custom renderers and validators as needed.

  • formik:

    formik does not natively support schema-based form generation. However, it can be integrated with schema validation libraries like Yup to provide schema-based validation. This allows developers to define validation rules in a schema-like format, which Formik can then use to validate form fields.

  • react-final-form:

    react-final-form does not provide built-in support for schema-based form generation or validation. It focuses on providing a flexible and performant form state management solution, allowing developers to implement their own validation logic as needed. Schema-based validation can be integrated manually or through third-party libraries.

  • react-hook-form:

    react-hook-form does not natively support schema-based form generation but offers seamless integration with schema validation libraries like Yup, Zod, and Joi. This allows developers to define validation schemas externally and use them within the form, ensuring a clear separation of concerns and more maintainable code.

  • react-jsonschema-form:

    react-jsonschema-form is built around JSON Schema, automatically generating forms based on the provided schema. It supports all standard JSON Schema features, including validation, default values, and nested structures. The library also allows for customization of the generated forms through UI schema definitions and custom widgets.

  • uniforms:

    uniforms supports multiple schema formats, including JSON Schema, GraphQL, and SimpleSchema. It allows for automatic form generation based on the provided schema, with support for nested structures, validation, and default values. The library is highly customizable, enabling developers to create custom components and widgets while leveraging the schema for form rendering and validation.

Validation

  • @jsonforms/react:

    @jsonforms/react supports validation based on JSON Schema, including required fields, data types, and custom validation rules. It allows for real-time validation and error display, with the ability to customize error messages and validation logic. The library also supports asynchronous validation and integration with external validation services.

  • formik:

    formik provides built-in support for validation through its validate function and integration with third-party validation libraries like Yup. It allows for both synchronous and asynchronous validation, with support for field-level, form-level, and schema-based validation. Formik also provides tools for displaying validation errors and managing form state during validation.

  • react-final-form:

    react-final-form offers flexible validation capabilities, allowing developers to implement field-level, form-level, and asynchronous validation. It provides a simple API for defining validation functions and integrates well with third-party validation libraries. The library also supports real-time validation and error handling, with tools for displaying validation messages and managing form state.

  • react-hook-form:

    react-hook-form provides built-in validation support, including required fields, min/max values, and pattern matching. It also integrates seamlessly with external validation libraries like Yup, allowing for schema-based validation. The library is designed to minimize re-renders during validation, making it highly performant for large forms.

  • react-jsonschema-form:

    react-jsonschema-form uses JSON Schema for validation, automatically enforcing rules defined in the schema, such as required fields, data types, and custom validation keywords. It provides real-time validation feedback and error messages, which can be customized through the UI schema or by providing custom error templates.

  • uniforms:

    uniforms supports validation based on the provided schema, including required fields, data types, and custom validation rules. It allows for real-time validation and error display, with support for asynchronous validation and integration with external validation libraries. The library also provides tools for customizing validation messages and handling complex validation scenarios.

Customization

  • @jsonforms/react:

    @jsonforms/react is highly customizable, allowing developers to create custom renderers, layouts, and validation logic. It provides a flexible architecture that supports the integration of third-party UI libraries and components. The library also allows for theming and styling, making it easy to adapt the forms to match the application's design.

  • formik:

    formik offers a high degree of customization, allowing developers to control the form structure, styling, and validation logic. It provides a simple API for managing form state, making it easy to integrate with custom components and third-party libraries. Formik also supports custom input components, error messages, and form layouts.

  • react-final-form:

    react-final-form is designed to be highly customizable, providing fine-grained control over form state, validation, and rendering. It allows developers to create custom input components, validation logic, and form layouts. The library's modular architecture makes it easy to extend and integrate with other tools and libraries.

  • react-hook-form:

    react-hook-form is highly customizable, allowing developers to create custom input components, validation rules, and error messages. It provides a flexible API for managing form state and integrates well with third-party libraries and UI frameworks. The library also supports theming and styling, making it easy to adapt forms to different design requirements.

  • react-jsonschema-form:

    react-jsonschema-form allows for customization of the generated forms through UI schema definitions, which control the layout, styling, and behavior of the form elements. Developers can also create custom widgets and field templates to replace the default components, providing greater flexibility in how the forms are rendered.

  • uniforms:

    uniforms is highly customizable, allowing developers to create custom components, widgets, and layouts while leveraging the schema for form generation. It supports theming and styling, making it easy to integrate with various UI frameworks. The library's flexibility makes it suitable for complex forms that require specialized behavior and appearance.

Performance

  • @jsonforms/react:

    @jsonforms/react is designed to be efficient, but performance can vary depending on the complexity of the JSON schema and the number of custom renderers used. The library leverages React's rendering optimizations, but developers should be mindful of potential performance bottlenecks when working with large or deeply nested schemas.

  • formik:

    formik is generally performant for most use cases, but it can suffer from unnecessary re-renders, especially in large forms with many fields. Developers need to be careful with how they structure their forms and may need to use techniques like memoization to optimize performance.

  • react-final-form:

    react-final-form is optimized for performance, with a focus on minimizing re-renders and managing form state efficiently. It uses a subscription-based model that allows components to only re-render when the specific parts of the form state they depend on change, making it ideal for large and complex forms.

  • react-hook-form:

    react-hook-form is built with performance in mind, leveraging uncontrolled components and refs to minimize re-renders. It is one of the most performant form libraries for React, especially for large forms, as it only triggers re-renders when necessary, resulting in faster and more efficient form handling.

  • react-jsonschema-form:

    react-jsonschema-form performance depends on the complexity of the JSON schema and the number of fields in the form. While it is generally efficient, rendering large or deeply nested forms can lead to performance issues. Developers should optimize schemas and use techniques like lazy loading or code splitting for complex forms.

  • uniforms:

    uniforms is designed for performance, but the impact depends on the complexity of the schema and the number of custom components used. The library leverages React's rendering optimizations, but developers should be mindful of potential performance issues when working with large or deeply nested forms.

Ease of Use: Code Examples

  • @jsonforms/react:

    @jsonforms/react Example

    import React from 'react';
import { JsonForms } from '@jsonforms/react';
import { materialRenderers } from '@jsonforms/material-renderers';

const schema = {
  type: 'object',
  properties: {
    name: { type: 'string' },
    age: { type: 'integer' },
  },
  required: ['name'],
};

const uischema = {
  type: 'VerticalLayout',
  elements: [
    { type: 'Control', scope: '#/properties/name' },
    { type: 'Control', scope: '#/properties/age' },
  ],
};

const App = () => {
  const [data, setData] = React.useState({});

  return (
    <JsonForms
      schema={schema}
      uischema={uischema}
      data={data}
      onChange={({ data }) => setData(data)}
      renderers={materialRenderers}
    />
  );
};

export default App;
  • formik:

    formik Example

    import React from 'react';
import { Formik, Form, Field, ErrorMessage } from 'formik';
import * as Yup from 'yup';

const validationSchema = Yup.object({
  name: Yup.string().required('Name is required'),
  email: Yup.string().email('Invalid email').required('Email is required'),
});

const App = () => (
  <Formik
    initialValues={{ name: '', email: '' }}
    validationSchema={validationSchema}
    onSubmit={(values) => {
      console.log(values);
    }}
  >
    {() => (
      <Form>
        <div>
          <label htmlFor="name">Name</label>
          <Field id="name" name="name" />
          <ErrorMessage name="name" />
        </div>
        <div>
          <label htmlFor="email">Email</label>
          <Field id="email" name="email" type="email" />
          <ErrorMessage name="email" />
        </div>
        <button type="submit">Submit</button>
      </Form>
    )}
  </Formik>
);

export default App;
  • react-final-form:

    react-final-form Example

    import React from 'react';
import { Form, Field } from 'react-final-form';

const validate = (values) => {
  const errors = {};
  if (!values.name) {
    errors.name = 'Name is required';
  }
  if (!values.email) {
    errors.email = 'Email is required';
  }
  return errors;
};

const App = () => (
  <Form
    onSubmit={(values) => {
      console.log(values);
    }}
    validate={validate}
    render={({ handleSubmit }) => (
      <form onSubmit={handleSubmit}>
        <div>
          <label>Name</label>
          <Field name="name" />
        </div>
        <div>
          <label>Email</label>
          <Field name="email" type="email" />
        </div>
        <button type="submit">Submit</button>
      </form>
    )}
  />
);

export default App;
  • react-hook-form:

    react-hook-form Example

    import React from 'react';
import { useForm } from 'react-hook-form';

const App = () => {
  const { register, handleSubmit, formState: { errors } } = useForm();

  const onSubmit = (data) => {
    console.log(data);
  };

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      <div>
        <label>Name</label>
        <input {...register('name', { required: 'Name is required' })} />
        {errors.name && <p>{errors.name.message}</p>}
      </div>
      <div>
        <label>Email</label>
        <input
          type="email"
          {...register('email', {
            required: 'Email is required',
            pattern: {
              value: /^[^@\s]+@[^@\s]+\.[^@\s]+$/,
              message: 'Invalid email address',
            },
          })}
        />
        {errors.email && <p>{errors.email.message}</p>}
      </div>
      <button type="submit">Submit</button>
    </form>
  );
};

export default App;
  • react-jsonschema-form:

    react-jsonschema-form Example

    import React from 'react';
import Form from '@rjsf/core';

const schema = {
  title: 'Example Form',
  type: 'object',
  required: ['name', 'email'],
  properties: {
    name: { type: 'string', title: 'Name' },
    email: { type: 'string', format: 'email', title: 'Email' },
  },
};

const App = () => {
  const onSubmit = ({ formData }) => {
    console.log('Data submitted: ', formData);
  };

  return <Form schema={schema} onSubmit={onSubmit} />;
};

export default App;
  • uniforms:

    uniforms Example

    import React from 'react';
import { AutoForm } from 'uniforms-unstyled';
import { JSONSchemaBridge } from 'uniforms-bridge-json-schema';
import { createValidator } from 'uniforms-bridge-simple-schema';

const schema = {
  title: 'Example Form',
  type: 'object',
  properties: {
    name: { type: 'string', title: 'Name' },
    email: { type: 'string', format: 'email', title: 'Email' },
  },
  required: ['name', 'email'],
};

const validator = createValidator(schema);
const bridge = new JSONSchemaBridge(schema, validator);

const App = () => {
  const handleSubmit = (data) => {
    console.log('Form submitted:', data);
  };

  return <AutoForm schema={bridge} onSubmit={handleSubmit} />;
};

export default App;

How to Choose: @jsonforms/react vs formik vs react-final-form vs react-hook-form vs react-jsonschema-form vs uniforms

  • @jsonforms/react:

    Choose @jsonforms/react if you need a highly customizable and extensible form rendering solution that supports complex JSON schemas. It is ideal for applications that require dynamic form generation based on JSON data, with support for custom renderers and validation.

  • formik:

    Choose formik if you want a simple yet powerful form management library that integrates well with React. It is suitable for applications that need straightforward form handling with built-in validation, error handling, and support for third-party validation libraries like Yup.

  • react-final-form:

    Choose react-final-form if you need a lightweight and performant form library with fine-grained control over form state. It is ideal for applications that require advanced features like field-level validation, dynamic forms, and optimized rendering, while keeping the bundle size small.

  • react-hook-form:

    Choose react-hook-form if you prioritize performance and minimal re-renders. It leverages React hooks for form management, making it a great choice for modern React applications that need efficient form handling with minimal boilerplate.

  • react-jsonschema-form:

    Choose react-jsonschema-form if you need a form generator that automatically creates forms based on JSON schemas. It is perfect for applications that require quick form creation from schema definitions, with support for validation and customization.

  • uniforms:

    Choose uniforms if you want a highly customizable form library that supports multiple schema formats (JSON Schema, GraphQL, SimpleSchema). It is ideal for applications that need flexible form generation with support for various UI frameworks and advanced features like nested forms and custom widgets.

Similar Npm Packages to @jsonforms/react

@jsonforms/react is a powerful library for building forms in React applications using JSON Schema. It provides a set of components and utilities that help developers create dynamic forms based on JSON Schema definitions, making it easier to handle complex form structures and validations. While @jsonforms/react offers a robust solution for form management, there are several alternatives in the React ecosystem that cater to different form handling needs. Here are a few notable alternatives:

  • formik is a popular library for managing forms in React applications. It simplifies form handling by providing a set of hooks and components that manage form state, validation, and submission. Formik is particularly useful for complex forms that require validation and error handling. Its flexibility allows developers to integrate it with various validation libraries, making it a versatile choice for many React applications.

  • react-final-form is another form management library that focuses on performance and simplicity. It is built on top of the Final Form core, providing a React-specific API. React Final Form allows for easy integration with existing forms and offers features like field-level validation, form state management, and more. It is a great choice for developers who want a lightweight solution without sacrificing performance.

  • react-hook-form is a library that leverages React hooks to manage form state and validation. It is designed to be simple and performant, minimizing re-renders and optimizing performance. React Hook Form is particularly beneficial for large forms or applications where performance is critical. Its API is intuitive, making it easy for developers to get started quickly.

  • react-jsonschema-form is a library that allows developers to create forms based on JSON Schema definitions. It provides a set of components that automatically generate forms from JSON Schema, making it easy to create dynamic forms with minimal effort. This library is ideal for applications that require forms to be generated based on external data or configurations.

  • uniforms is a set of libraries for building forms in React based on JSON Schema, GraphQL, or other data models. It provides a flexible and customizable way to create forms, allowing developers to define their own components and layouts. Uniforms is suitable for applications that require a high degree of customization and flexibility in form design.

To see how @jsonforms/react compares with formik, react-final-form, react-hook-form, react-jsonschema-form, and uniforms, check out the comparison: Comparing @jsonforms/react vs formik vs react-final-form vs react-hook-form vs react-jsonschema-form vs uniforms.

Similar Npm Packages to formik

formik is a popular library for managing forms in React applications. It simplifies form handling by providing a set of utilities that help with form state management, validation, and submission. Formik is particularly useful for complex forms that require validation and dynamic field management, making it a go-to choice for many React developers. However, there are several alternatives that also cater to form management in React. Here are a few noteworthy options:

  • formik-material-ui is a wrapper around Formik that integrates Material-UI components with Formik's form management capabilities. This library allows developers to easily create forms using Material-UI components while leveraging Formik's powerful features for state management and validation. If you are already using Material-UI in your project and want to streamline form handling, formik-material-ui is an excellent choice.

  • react-final-form is a lightweight alternative to Formik that focuses on performance and simplicity. It is based on the Final Form library and provides a flexible API for managing form state. React Final Form allows for easy integration with various UI libraries and is particularly suitable for applications that require high performance with minimal overhead. If you prefer a more functional approach to form management, react-final-form is worth considering.

  • react-hook-form is another popular library that leverages React hooks for form management. It offers a simple and performant way to handle forms with minimal re-renders, making it a great choice for applications where performance is critical. React Hook Form is easy to integrate with existing UI libraries and provides built-in validation support. If you are looking for a modern and efficient way to manage forms in React, react-hook-form is a strong contender.

  • react-jsonschema-form is a library that allows you to create forms based on JSON Schema. It automatically generates form fields based on the schema definition, making it a great option for applications that require dynamic form generation. If your project involves working with JSON data structures and you want to automate form creation, react-jsonschema-form is an excellent choice.

  • redux-form is a library that integrates form management with Redux, allowing you to manage form state in the Redux store. While it provides powerful capabilities for managing complex forms, it may introduce additional complexity due to its reliance on Redux. If your application is already using Redux and you want to manage form state alongside your global state, redux-form can be a suitable option.

To explore how these libraries compare, check out the following link: Comparing formik vs formik-material-ui vs react-final-form vs react-hook-form vs react-jsonschema-form vs redux-form.

Similar Npm Packages to react-final-form

react-final-form is a powerful library for managing forms in React applications. It is built on top of Final Form, which provides a flexible and efficient way to handle form state, validation, and submission. With its minimalistic API and focus on performance, react-final-form allows developers to create complex forms with ease, while maintaining a clean and maintainable codebase. It supports features like field-level validation, nested fields, and dynamic form structures, making it a versatile choice for various form-related tasks.

While react-final-form is a great option, there are other libraries available that also provide form management solutions. Here are a couple of alternatives:

  • formik is one of the most popular form libraries for React. It simplifies form handling by providing a set of components and hooks that manage form state, validation, and submission. Formik is particularly well-suited for handling complex forms with validation requirements, as it integrates seamlessly with various validation libraries. Its intuitive API and extensive documentation make it easy for developers to get started quickly, making it a go-to choice for many React developers.
  • redux-form is another form management library that integrates with Redux, allowing developers to manage form state in the Redux store. This can be particularly useful for applications that already use Redux for state management, as it provides a consistent approach to handling form data alongside other application state. However, it's worth noting that redux-form has fallen out of favor in recent years due to its complexity and performance concerns compared to newer libraries like Formik and React Final Form.

To see how react-final-form compares with formik and redux-form, check out the comparison: Comparing formik vs react-final-form vs redux-form.

Similar Npm Packages to react-hook-form

react-hook-form is a popular library for managing forms in React applications. It provides a simple and performant way to handle form validation, submission, and state management using React hooks. With its minimal re-renders and easy integration with UI libraries, react-hook-form is an excellent choice for developers looking to build forms efficiently. However, there are several alternatives in the React ecosystem that also offer form management solutions. Here are a few noteworthy options:

  • formik is a well-established library for building forms in React. It provides a robust set of features for handling form state, validation, and submission. Formik is particularly useful for managing complex forms with nested fields and validation schemas. Its API is intuitive, making it easy to integrate into existing applications. If you need a comprehensive solution that offers a lot of built-in functionality, formik is a strong contender.

  • react-final-form is a lightweight form library that focuses on performance and simplicity. It is based on the Final Form library and provides a flexible API for managing form state and validation. react-final-form is designed to minimize re-renders and improve performance, making it suitable for applications with large forms or complex validation logic. If you're looking for a performant solution with a straightforward API, react-final-form is worth considering.

  • react-jsonschema-form is a library for building forms based on JSON Schema. It automatically generates form fields based on the provided schema, making it a great choice for applications that require dynamic forms. This library is particularly useful for developers who want to create forms without manually defining each input field. If your application relies heavily on JSON Schema for form definitions, react-jsonschema-form can save you time and effort.

  • redux-form is a library that integrates form state management with Redux. It allows you to manage form state in a Redux store, making it suitable for applications that already use Redux for state management. While it provides powerful features for handling forms, it can introduce additional complexity due to its reliance on Redux. If you are already using Redux and want to manage forms within that context, redux-form may be a good fit.

To explore how these libraries compare, check out the following link: Comparing formik vs react-final-form vs react-hook-form vs react-jsonschema-form vs redux-form.

Similar Npm Packages to react-jsonschema-form

react-jsonschema-form is a popular library for building forms in React applications using JSON Schema. It allows developers to create complex forms with minimal effort by defining the form structure and validation rules in a JSON format. This approach makes it easy to manage form state and validation while ensuring that the forms are dynamic and adaptable. However, there are several alternatives available that also provide powerful form handling capabilities. Here are a few notable options:

  • formik is a widely-used library for managing form state in React applications. It simplifies the process of handling form inputs, validation, and submission. Formik provides a flexible API that allows developers to create forms with ease, including support for complex validation and nested fields. If you are looking for a robust solution that integrates well with React's component model and offers extensive customization options, Formik is an excellent choice.
  • react-final-form is another form management library that focuses on performance and simplicity. It is built on the principles of Final Form, which emphasizes minimal re-renders and efficient state management. React Final Form allows developers to create forms with a straightforward API while providing powerful features such as field-level validation and dynamic field arrays. If you need a lightweight solution that prioritizes performance, React Final Form is worth considering.
  • react-hook-form is a library that leverages React hooks to manage form state and validation. It is designed for performance and simplicity, allowing developers to create forms with minimal boilerplate code. React Hook Form supports uncontrolled components, which can lead to better performance in larger forms. If you prefer a hook-based approach and want to minimize re-renders while maintaining a clean codebase, React Hook Form is a great option.

To explore how these libraries compare, check out the following link: Comparing formik vs react-final-form vs react-hook-form vs react-jsonschema-form.

Similar Npm Packages to uniforms

uniforms is a powerful library for building forms in React applications. It provides a set of tools and components that simplify the process of creating, validating, and managing forms. With its schema-based approach, uniforms allows developers to define their forms using schemas from various libraries, making it flexible and adaptable to different use cases. While uniforms offers a robust solution for form management, there are several alternatives in the React ecosystem worth considering:

  • final-form is a lightweight and flexible library for managing form state in React applications. It provides a simple API for handling form inputs, validation, and submission. final-form is designed to be minimalistic, allowing developers to use it in a variety of contexts without imposing a specific structure. If you prefer a library that offers fine-grained control over form state and behavior, final-form is an excellent choice.
  • formik is one of the most popular form management libraries in the React ecosystem. It simplifies the process of handling forms by providing a set of components and hooks that manage form state, validation, and submission. formik is particularly well-suited for complex forms with multiple fields and validation requirements. If you are looking for a comprehensive solution with a large community and extensive documentation, formik is a solid option.
  • react-hook-form is a performant and easy-to-use library for managing forms in React applications. It leverages React hooks to provide a simple API for handling form state and validation. react-hook-form is known for its minimal re-renders and high performance, making it ideal for applications with large forms or complex validation logic. If performance is a key concern for your project, react-hook-form is worth considering.

For a detailed comparison of these libraries, check out the following link: Comparing final-form vs formik vs react-hook-form vs uniforms.

README for @jsonforms/react

JSON Forms - More Forms. Less Code

Complex forms in the blink of an eye

JSON Forms eliminates the tedious task of writing fully-featured forms by hand by leveraging the capabilities of JSON, JSON Schema and Javascript.

React Package

This is the JSON Forms React package which provides the necessary bindings for React. It uses JSON Forms Core.

You can combine the react package with any react-based renderer set you want, for example the Material Renderers or the Vanilla Renderers.

See the official documentation and the JSON Forms React seed repository for examples on how to integrate JSON Forms with your application.

Check https://www.npmjs.com/search?q=%40jsonforms for all published JSON Forms packages.

Usage

Use the JsonForms component to render a form for your data.

Mandatory props:

  • data: any - the data to show
  • renderers: JsonFormsRendererRegistryEntry[] - the React renderer set to use

Optional props:

  • schema: JsonSchema - the data schema for the given data. Will be generated when not given.
  • uischema: UISchemaElement - the UI schema for the given data schema. Will be generated when not given.
  • cells: JsonFormsCellRendererRegistryEntry[] - the React cell renderer set to use
  • config: any - form-wide options. May contain default ui schema options.
  • readonly: boolean - whether all controls shall be readonly.
  • uischemas: JsonFormsUiSchemaEntry[] - registry for dynamic ui schema dispatching
  • validationMode: 'ValidateAndShow' | 'ValidateAndHide' | 'NoValidation' - the validation mode for the form
  • ajv: AJV - custom Ajv instance for the form
  • middleware: Middleware - can be used to hook into the form-wide data management.
  • i18n: JsonFormsI18nState - can be used to internationalize the rendered form.
  • onChange - callback which is called initially and on each data change, containing the updated data and the validation result.

Example:

import React, { useState } from 'react';
import {
  materialRenderers,
  materialCells,
} from '@jsonforms/material-renderers';
import { JsonForms } from '@jsonforms/react';

const schema = {
  type: 'object',
  properties: {
    name: {
      type: 'string',
      minLength: 1,
    },
    done: {
      type: 'boolean',
    },
    due_date: {
      type: 'string',
      format: 'date',
    },
    recurrence: {
      type: 'string',
      enum: ['Never', 'Daily', 'Weekly', 'Monthly'],
    },
  },
  required: ['name', 'due_date'],
};
const uischema = {
  type: 'VerticalLayout',
  elements: [
    {
      type: 'Control',
      label: false,
      scope: '#/properties/done',
    },
    {
      type: 'Control',
      scope: '#/properties/name',
    },
    {
      type: 'HorizontalLayout',
      elements: [
        {
          type: 'Control',
          scope: '#/properties/due_date',
        },
        {
          type: 'Control',
          scope: '#/properties/recurrence',
        },
      ],
    },
  ],
};
const initialData = {};
function App() {
  const [data, setData] = useState(initialData);
  return (
    <JsonForms
      schema={schema}
      uischema={uischema}
      data={data}
      renderers={materialRenderers}
      cells={materialCells}
      onChange={({ data, _errors }) => setData(data)}
    />
  );
}
export default App;

License

The JSON Forms project is licensed under the MIT License. See the LICENSE file for more information.

Roadmap

Our current roadmap is available here.

Feedback, Help and Support

JSON Forms is developed by EclipseSource.

If you encounter any problems feel free to open an issue on the repo. For questions and discussions please use the JSON Forms board. You can also reach us via email. In addition, EclipseSource also offers professional support for JSON Forms.

Migration

See our migration guide when updating JSON Forms.

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.