Logo for jsDocs.io

formsy-react

  • Version 2.4.6
  • Published
  • 67.1 kB
  • 1 dependency
  • MIT license

Install

npm i formsy-react
yarn add formsy-react
pnpm add formsy-react

Overview

A form input builder and validator for React

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable validationRules

const validationRules: Validations<any>;

    Functions

    function addValidationRule

    addValidationRule: <V>(name: string, func: ValidationFunction<V>) => void;

      function withFormsy

      withFormsy: <T, V>(
          WrappedComponent: React.ComponentType<T & WrapperProps<V> & InjectedProps<V>>
      ) => React.ComponentType<Omit<T & WrapperProps<V>, keyof InjectedProps<V>>>;

        Classes

        class Formsy

        class Formsy extends React.Component<PropsWithChildren<FormsyProps>, FormsyState> {}

          constructor

          constructor(props: FormsyProps);

            property attachToForm

            attachToForm: (component: any) => void;

              property componentDidMount

              componentDidMount: () => void;

                property componentDidUpdate

                componentDidUpdate: (prevProps: FormsyProps) => void;

                  property componentWillUnmount

                  componentWillUnmount: () => void;

                    property detachFromForm

                    detachFromForm: <V>(component: InputComponent<V>) => void;

                      property displayName

                      static displayName: string;

                        property emptyArray

                        emptyArray: any[];

                          property getCurrentValues

                          getCurrentValues: () => any;

                            property getModel

                            getModel: () => any;

                              property getPristineValues

                              getPristineValues: () => any;

                                property inputs

                                inputs: any[];

                                  property isChanged

                                  isChanged: () => boolean;

                                    property isFormDisabled

                                    isFormDisabled: () => boolean;

                                      property isValidValue

                                      isValidValue: (component: any, value: any) => boolean;

                                        property mapModel

                                        mapModel: (model: IModel) => IModel;

                                          property prevInputNames

                                          prevInputNames: any[];

                                            property reset

                                            reset: (model?: IModel) => void;

                                              property runValidation

                                              runValidation: <V>(
                                                  component: InputComponent<V>,
                                                  value?: V
                                              ) => {
                                                  isRequired: boolean;
                                                  isValid: boolean;
                                                  validationError: ValidationError[];
                                              };

                                                property setFormPristine

                                                setFormPristine: (isPristine: boolean) => void;

                                                  property setFormValidState

                                                  setFormValidState: (allIsValid: boolean) => void;

                                                    property setInputValidationErrors

                                                    setInputValidationErrors: (errors: any) => void;

                                                      property submit

                                                      submit: (event?: React.SyntheticEvent<HTMLFormElement>) => void;

                                                        property updateInputsWithError

                                                        updateInputsWithError: IUpdateInputsWithError;

                                                          property updateInputsWithValue

                                                          updateInputsWithValue: IUpdateInputsWithValue<any>;

                                                            property validate

                                                            validate: <V>(component: InputComponent<V>) => void;

                                                              property validateForm

                                                              validateForm: () => void;

                                                                method render

                                                                render: () => React.FunctionComponentElement<
                                                                    React.ProviderProps<FormsyContextInterface>
                                                                >;

                                                                  Interfaces

                                                                  interface InjectedProps

                                                                  interface InjectedProps<V> {}

                                                                    property errorMessage

                                                                    errorMessage: ValidationError;

                                                                      property errorMessages

                                                                      errorMessages: ValidationError[];

                                                                        property hasValue

                                                                        hasValue: boolean;

                                                                          property isFormDisabled

                                                                          isFormDisabled: boolean;

                                                                            property isFormSubmitted

                                                                            isFormSubmitted: boolean;

                                                                              property isPristine

                                                                              isPristine: boolean;

                                                                                property isRequired

                                                                                isRequired: boolean;

                                                                                  property isValid

                                                                                  isValid: boolean;

                                                                                    property isValidValue

                                                                                    isValidValue: (value: V) => boolean;

                                                                                      property ref

                                                                                      ref?: React.Ref<any>;

                                                                                        property resetValue

                                                                                        resetValue: () => void;

                                                                                          property setValidations

                                                                                          setValidations: (
                                                                                              validations: Validations<V>,
                                                                                              required: RequiredValidation<V>
                                                                                          ) => void;

                                                                                            property setValue

                                                                                            setValue: (value: V, validate?: boolean) => void;

                                                                                              property showError

                                                                                              showError: boolean;

                                                                                                property showRequired

                                                                                                showRequired: boolean;

                                                                                                  interface WrapperProps

                                                                                                  interface WrapperProps<V> {}

                                                                                                    property innerRef

                                                                                                    innerRef?: (ref: React.Ref<any>) => void;

                                                                                                      property name

                                                                                                      name: string;

                                                                                                        property required

                                                                                                        required?: RequiredValidation<V>;

                                                                                                          property validationError

                                                                                                          validationError?: ValidationError;

                                                                                                            property validationErrors

                                                                                                            validationErrors?: {
                                                                                                                [key: string]: ValidationError;
                                                                                                            };

                                                                                                              property validations

                                                                                                              validations?: Validations<V>;

                                                                                                                property value

                                                                                                                value?: V;

                                                                                                                  Type Aliases

                                                                                                                  type FormsyInjectedProps

                                                                                                                  type PassDownProps<V> = WrapperProps<V> & InjectedProps<V>;

                                                                                                                    Package Files (4)

                                                                                                                    Dependencies (1)

                                                                                                                    Dev Dependencies (24)

                                                                                                                    Peer Dependencies (2)

                                                                                                                    Badge

                                                                                                                    To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                    You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/formsy-react.

                                                                                                                    • Markdown
                                                                                                                      [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/formsy-react)
                                                                                                                    • HTML
                                                                                                                      <a href="https://www.jsdocs.io/package/formsy-react"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>