function getSubComponents()

in modules/material-parser/src/parse/js/resolver/index.ts [167:262]
74 lines of code
23 McCabe index (conditional complexity)

function getSubComponents(path: any, scope: any, cache: ICache) {
  // Extract all methods from the class or object.
  let methodPaths = [];
  if (isReactComponentClass(path)) {
    methodPaths = path.get('body', 'body').filter(isStaticMethod);
    methodPaths = [...methodPaths, ...findAssignedMethods(scope || path.scope, path.get('id'))];
  } else if (t.ObjectExpression.check(path.node)) {
    methodPaths = path.get('properties').filter(isStaticMethod);
    methodPaths = [...methodPaths, ...findAssignedMethods(scope || path.scope, path.get('id'))];
    // Add the statics object properties.
    const statics = getMemberValuePath(path, 'statics');
    if (statics) {
      statics.get('properties').each((p: any) => {
        if (isStaticMethod(p)) {
          p.node.static = true;
          methodPaths.push(p);
        }
      });
    }
  } else if (
    t.VariableDeclarator.check(path.parent.node) &&
    path.parent.node.init === path.node &&
    t.Identifier.check(path.parent.node.id)
  ) {
    methodPaths = findAssignedMethods(scope || path.parent.scope, path.parent.get('id'));
  } else if (
    t.AssignmentExpression.check(path.parent.node) &&
    path.parent.node.right === path.node &&
    t.Identifier.check(path.parent.node.left)
  ) {
    methodPaths = findAssignedMethods(scope || path.parent.scope, path.parent.get('left'));
  } else if (t.FunctionDeclaration.check(path.node)) {
    methodPaths = findAssignedMethods(scope || path.parent.scope, path.get('id'));
  } else if (t.ArrowFunctionExpression.check(path.node)) {
    methodPaths = findAssignedMethods(scope || path.parent.scope, path.parent.get('id'));
  }

  return (
    methodPaths
      .map((x: any) => {
        if (t.ClassProperty.check(x.node)) {
          return {
            value: x.get('value'),
            subName: x.node.key.name,
            localName: getName(x.get('value')),
          };
        }
        return {
          value: x,
          subName: x.node.left.property.name,
          localName: getName(x.get('right')),
        };
      })
      .map(({ subName, localName, value }: IMethodsPath) => ({
        subName,
        localName,
        value: resolveToValue(value),
      }))
      .map(({ subName, localName, value }: IMethodsPath) => {
        let def = getDefinition(
          makeProxy(value, {
            __meta: {
              localName,
              subName,
              exportName: path.__meta && path.__meta.exportName,
            },
          }),
          cache,
        );
        if (!Array.isArray(def)) {
          def = [def];
        }
        return {
          subName,
          localName,
          value: def.flatMap((x: any) => x).filter((x: any) => isComponentDefinition(x)),
        };
      })
      .map(({ subName, localName, value }: IMethodsPath) => {
        return value.map((x: any) => ({
          subName,
          localName,
          value: x,
        }));
      })
      // @ts-ignore
      .flatMap((x: any) => x)
      .map(({ subName, value }: IMethodsPath) => {
        const __meta = {
          subName,
          exportName: path.__meta && path.__meta.exportName,
        };
        return makeProxy(value, { __meta });
      })
  );
}