Function resolveToValue

packages/react-docgen/src/utils/resolveToValue.ts:121–232

(path: NodePath)

 * Else the path itself is returned.
 */
export default function resolveToValue(path: NodePath): NodePath {
  if (path.isIdentifier()) {
    if (
      (path.parentPath.isClass() || path.parentPath.isFunction()) &&
      path.parentPath.get('id') === path
    ) {
      return path.parentPath;
    }

    const binding = path.scope.getBinding(path.node.name);
    let resolvedPath: NodePath | null = null;

    if (binding) {
      // The variable may be assigned a different value after initialization.
      // We are first trying to find all assignments to the variable in the
      // block where it is defined (i.e. we are not traversing into statements)
      resolvedPath = findLastAssignedValue(binding.scope.path, path);
      if (!resolvedPath) {
        const bindingMap = binding.path.getOuterBindingIdentifierPaths(true);

        resolvedPath = findScopePath(bindingMap[path.node.name]);
      }
    } else {
      // Initialize our monkey-patching of @babel/traverse 🙈
      initialize(Scope);
      const typeBinding = path.scope.getTypeBinding(path.node.name);

      if (typeBinding) {
        resolvedPath = findScopePath([typeBinding.identifierPath]);
      }
    }

    return resolvedPath || path;
  } else if (path.isVariableDeclarator()) {
    const init = path.get('init');

    if (init.hasNode()) {
      return resolveToValue(init);
    }
  } else if (path.isMemberExpression()) {
    const root = getMemberExpressionRoot(path);
    const resolved = resolveToValue(root);

    if (resolved.isObjectExpression()) {
      let propertyPath: NodePath | null = resolved;

      for (const propertyName of toArray(path).slice(1)) {
        if (propertyPath && propertyPath.isObjectExpression()) {
          propertyPath = getPropertyValuePath(propertyPath, propertyName);
        }
        if (!propertyPath) {
          return path;
        }
        propertyPath = resolveToValue(propertyPath);
      }

      return propertyPath;
    } else if (isSupportedDefinitionType(resolved)) {