function handleGenericTypeAnnotation()

in src/utils/getFlowType.ts [108:178]
61 lines of code
17 McCabe index (conditional complexity)

function handleGenericTypeAnnotation(
  path: NodePath,
  typeParams: TypeParameters | null,
  importer: Importer,
): TypeDescriptor | null {
  if (path.node.id.name === '$Keys' && path.node.typeParameters) {
    return handleKeysHelper(path, importer);
  }

  let type: TypeDescriptor;
  if (t.QualifiedTypeIdentifier.check(path.node.id)) {
    const id = path.get('id');

    if (id.node.qualification.name === 'React') {
      type = {
        name: `${id.node.qualification.name}${id.node.id.name}`,
        raw: printValue(id),
      };
    } else {
      type = { name: printValue(id).replace(/<.*>$/, '') };
    }
  } else {
    type = { name: path.node.id.name };
  }

  const resolvedPath =
    (typeParams && typeParams[type.name]) ||
    resolveToValue(path.get('id'), importer);

  if (path.node.typeParameters && resolvedPath.node.typeParameters) {
    typeParams = getTypeParameters(
      resolvedPath.get('typeParameters'),
      path.get('typeParameters'),
      typeParams,
      importer,
    );
  }

  if (
    typeParams &&
    typeParams[type.name] &&
    // @ts-ignore
    typeParams[type.name].value.type === t.GenericTypeAnnotation.name
  ) {
    return type;
  }

  if (typeParams && typeParams[type.name]) {
    type = getFlowTypeWithResolvedTypes(resolvedPath, typeParams, importer);
  }

  if (resolvedPath && resolvedPath.node.right) {
    type = getFlowTypeWithResolvedTypes(
      resolvedPath.get('right'),
      typeParams,
      importer,
    );
  } else if (path.node.typeParameters) {
    const params = path.get('typeParameters').get('params');

    type = {
      ...(type as SimpleType),
      elements: params.map((param: NodePath) =>
        getFlowTypeWithResolvedTypes(param, typeParams, importer),
      ),
      raw: printValue(path),
    };
  }

  return type;
}