Function convertObject

lib/utils/conversion-utils.js:100–199

(
  validator: TType<I>,
  input: I,
  typesToConvert: $ReadOnlyArray<TType<T>>,
  conversionFunction: T => T,
  options?: ?ConvertObjectOptions,
)

  +dontValidateInput?: ?boolean,
};
function convertObject<T, I>(
  validator: TType<I>,
  input: I,
  typesToConvert: $ReadOnlyArray<TType<T>>,
  conversionFunction: T => T,
  options?: ?ConvertObjectOptions,
): I {
  if (input === null || input === undefined) {
    return input;
  }
  const dontValidateInput = options?.dontValidateInput;

  // While they should be the same runtime object,
  // `tValidator` is `TType<T>` and `validator` is `TType<I>`.
  // Having them have different types allows us to use `assertWithValidator`
  // to change `input` flow type
  const tValidator = typesToConvert[typesToConvert.indexOf(validator)];
  if (tValidator && tValidator.is(input)) {
    const tInput = assertWithValidator(input, tValidator);
    const converted = conversionFunction(tInput);
    return assertWithValidator(converted, validator);
  }

  if (validator.meta.kind === 'maybe' || validator.meta.kind === 'subtype') {
    return convertObject(
      validator.meta.type,
      input,
      typesToConvert,
      conversionFunction,
      options,
    );
  }
  if (validator.meta.kind === 'interface' && typeof input === 'object') {
    const recastValidator: TInterface<typeof input> = (validator: any);
    const result: { [string]: mixed } = {};
    for (const key in input) {
      const innerValidator = recastValidator.meta.props[key];
      if (!innerValidator && recastValidator.meta.strict === false) {
        result[key] = input[key];
        continue;
      }
      result[key] = convertObject(
        innerValidator,
        input[key],
        typesToConvert,
        conversionFunction,
        options,
      );
    }
    if (dontValidateInput) {
      return (result: any);
    } else {
      return assertWithValidator(result, recastValidator);
    }
  }
  if (validator.meta.kind === 'union') {
    for (const innerValidator of validator.meta.types) {
      if (innerValidator.is(input)) {