Function runValidation

src/FinalForm.ts:400–555

(fieldChanged: string | undefined, callback: () => void)

  };

  const runValidation = (fieldChanged: string | undefined, callback: () => void) => {
    if (validationPaused) {
      validationBlocked = true;
      callback();
      return;
    }

    const { fields, formState } = state;
    const safeFields = { ...fields };
    let fieldKeys = Object.keys(safeFields);
    if (
      !validate &&
      !fieldKeys.some((key) => getValidators(safeFields[key]).length)
    ) {
      callback();
      return; // no validation rules
    }

    // pare down field keys to actually validate
    let limitedFieldLevelValidation = false;
    if (fieldChanged) {
      const changedField = safeFields[fieldChanged];
      if (changedField) {
        const { validateFields } = changedField;
        if (validateFields) {
          limitedFieldLevelValidation = true;
          fieldKeys = validateFields.length
            ? validateFields.concat(fieldChanged)
            : [fieldChanged];
        }
      }
    }

    let recordLevelErrors: AnyObject = {};
    let asyncRecordLevelErrors: AnyObject = {};
    const fieldLevelErrors: Record<string, any> = {};

    const promises = [
      ...runRecordLevelValidation((errors, wasAsync: boolean) => {
        if (wasAsync) {
          asyncRecordLevelErrors = errors || {};
        } else {
          recordLevelErrors = errors || {};
        }
      }),
      ...fieldKeys.reduce(
        (result, name) =>
          result.concat(
            runFieldLevelValidation(fields[name], (error: any) => {
              fieldLevelErrors[name] = error;
            }),
          ),
        [],
      ),
    ];

    const hasAsyncValidations = promises.length > 0;
    const asyncValidationPromiseKey = ++nextAsyncValidationKey;