rc-field-form

  • Version 2.7.0
  • Published
  • 292 kB
  • 3 dependencies
  • MIT license

Install

npm i rc-field-form
yarn add rc-field-form
pnpm add rc-field-form

Overview

React Form Component

Index

Variables

variable FieldContext

const FieldContext: React.Context<InternalFormInstance>;

    variable FormProvider

    const FormProvider: React.FunctionComponent<FormProviderProps>;

      variable ListContext

      const ListContext: React.Context<ListContextProps>;

        variable RefForm

        const RefForm: RefFormType;

          Functions

          function Field

          Field: <Values = any>({
          name,
          ...restProps
          }: FieldProps<Values>) => React.JSX.Element;

            function InternalForm

            InternalForm: <Values = any>(
            props: FormProps<Values> & { ref?: React.Ref<FormRef<Values>> }
            ) => React.ReactElement;

              function List

              List: <Values = any>({
              name,
              initialValue,
              children,
              rules,
              validateTrigger,
              isListField,
              }: ListProps<Values>) => React.JSX.Element;

                function useForm

                useForm: <Values = any>(form?: FormInstance<Values>) => [FormInstance<Values>];

                  function useWatch

                  useWatch: {
                  <
                  TDependencies1 extends keyof ReturnPromise<
                  ReturnType<TForm['validateFields']>
                  >,
                  TForm extends FormInstance<any>,
                  TDependencies2 extends keyof ReturnPromise<
                  ReturnType<TForm['validateFields']>
                  >[TDependencies1],
                  TDependencies3 extends keyof ReturnPromise<
                  ReturnType<TForm['validateFields']>
                  >[TDependencies1][TDependencies2],
                  TDependencies4 extends keyof ReturnPromise<
                  ReturnType<TForm['validateFields']>
                  >[TDependencies1][TDependencies2][TDependencies3]
                  >(
                  dependencies: [
                  TDependencies1,
                  TDependencies2,
                  TDependencies3,
                  TDependencies4
                  ],
                  form?: TForm | WatchOptions<TForm>
                  ): GetGeneric<TForm>[TDependencies1][TDependencies2][TDependencies3][TDependencies4];
                  <
                  TDependencies1 extends keyof ReturnPromise<
                  ReturnType<TForm['validateFields']>
                  >,
                  TForm extends FormInstance<any>,
                  TDependencies2 extends keyof ReturnPromise<
                  ReturnType<TForm['validateFields']>
                  >[TDependencies1],
                  TDependencies3 extends keyof ReturnPromise<
                  ReturnType<TForm['validateFields']>
                  >[TDependencies1][TDependencies2]
                  >(
                  dependencies: [TDependencies1, TDependencies2, TDependencies3],
                  form?: TForm | WatchOptions<TForm>
                  ): ReturnPromise<
                  ReturnType<TForm['validateFields']>
                  >[TDependencies1][TDependencies2][TDependencies3];
                  <
                  TDependencies1 extends keyof ReturnPromise<
                  ReturnType<TForm['validateFields']>
                  >,
                  TForm extends FormInstance<any>,
                  TDependencies2 extends keyof ReturnPromise<
                  ReturnType<TForm['validateFields']>
                  >[TDependencies1]
                  >(
                  dependencies: [TDependencies1, TDependencies2],
                  form?: TForm | WatchOptions<TForm>
                  ): ReturnPromise<
                  ReturnType<TForm['validateFields']>
                  >[TDependencies1][TDependencies2];
                  <
                  TDependencies extends keyof ReturnPromise<
                  ReturnType<TForm['validateFields']>
                  >,
                  TForm extends FormInstance<any>
                  >(
                  dependencies: TDependencies | [TDependencies],
                  form?: TForm | WatchOptions<TForm>
                  ): ReturnPromise<ReturnType<TForm['validateFields']>>[TDependencies];
                  <TForm extends FormInstance<any>>(
                  dependencies: [],
                  form?: TForm | WatchOptions<TForm>
                  ): ReturnPromise<ReturnType<TForm['validateFields']>>;
                  <TForm extends FormInstance<any>, TSelected = unknown>(
                  selector: (
                  values: ReturnPromise<ReturnType<TForm['validateFields']>>
                  ) => TSelected,
                  form?: TForm | WatchOptions<TForm>
                  ): TSelected;
                  <ValueType = Store, TSelected = unknown>(
                  selector: (values: ValueType) => TSelected,
                  form?: FormInstance<any> | WatchOptions<FormInstance<any>>
                  ): TSelected;
                  <TForm extends FormInstance<any>>(
                  dependencies: any,
                  form?: TForm | WatchOptions<TForm>
                  ): any;
                  <ValueType = Store>(
                  dependencies: any,
                  form?: FormInstance<any> | WatchOptions<FormInstance<any>>
                  ): ValueType;
                  };

                    Interfaces

                    interface FormInstance

                    interface FormInstance<Values = any> {}

                      property getFieldError

                      getFieldError: (name: NamePath<Values>) => string[];

                        property getFieldsError

                        getFieldsError: (nameList?: NamePath<Values>[]) => FieldError[];

                          property getFieldsValue

                          getFieldsValue: (() => Values) &
                          ((nameList: NamePath<Values>[] | true, filterFunc?: FilterFunc) => any) &
                          ((config: GetFieldsValueConfig) => any);

                            property getFieldValue

                            getFieldValue: (name: NamePath<Values>) => StoreValue;

                              property getFieldWarning

                              getFieldWarning: (name: NamePath<Values>) => string[];

                                property isFieldsTouched

                                isFieldsTouched: ((
                                nameList?: NamePath<Values>[],
                                allFieldsTouched?: boolean
                                ) => boolean) &
                                ((allFieldsTouched?: boolean) => boolean);

                                  property isFieldsValidating

                                  isFieldsValidating: (nameList?: NamePath<Values>[]) => boolean;

                                    property isFieldTouched

                                    isFieldTouched: (name: NamePath<Values>) => boolean;

                                      property isFieldValidating

                                      isFieldValidating: (name: NamePath<Values>) => boolean;

                                        property resetFields

                                        resetFields: (fields?: NamePath<Values>[]) => void;

                                          property setFields

                                          setFields: (fields: FieldData<Values>[]) => void;

                                            property setFieldsValue

                                            setFieldsValue: (values: RecursivePartial<Values>) => void;

                                              property setFieldValue

                                              setFieldValue: (name: NamePath<Values>, value: any) => void;

                                                property submit

                                                submit: () => void;

                                                  property validateFields

                                                  validateFields: ValidateFields<Values>;

                                                    interface FormProps

                                                    interface FormProps<Values = any> extends BaseFormProps {}

                                                      property children

                                                      children?: RenderProps | React.ReactNode;

                                                        property clearOnDestroy

                                                        clearOnDestroy?: boolean;

                                                          property component

                                                          component?: false | string | React.FC<any> | React.ComponentClass<any>;

                                                            property fields

                                                            fields?: FieldData[];

                                                              property form

                                                              form?: FormInstance<Values>;

                                                                property initialValues

                                                                initialValues?: Store;

                                                                  property name

                                                                  name?: string;

                                                                    property onFieldsChange

                                                                    onFieldsChange?: Callbacks<Values>['onFieldsChange'];

                                                                      property onFinish

                                                                      onFinish?: Callbacks<Values>['onFinish'];

                                                                        property onFinishFailed

                                                                        onFinishFailed?: Callbacks<Values>['onFinishFailed'];

                                                                          property onValuesChange

                                                                          onValuesChange?: Callbacks<Values>['onValuesChange'];

                                                                            property preserve

                                                                            preserve?: boolean;

                                                                              property validateMessages

                                                                              validateMessages?: ValidateMessages;

                                                                                property validateTrigger

                                                                                validateTrigger?: string | string[] | false;

                                                                                  Type Aliases

                                                                                  type FormRef

                                                                                  type FormRef<Values = any> = FormInstance<Values> & {
                                                                                  nativeElement?: HTMLElement;
                                                                                  };

                                                                                    Package Files (10)

                                                                                    Dependencies (3)

                                                                                    Dev Dependencies (26)

                                                                                    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/rc-field-form.

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