function getDefinition()

in modules/material-parser/src/parse/js/resolver/index.ts [58:155]
89 lines of code
24 McCabe index (conditional complexity)

function getDefinition(definition: any, cache: ICache = {}): any {
  const { __meta: exportMeta = {} } = definition;
  if (checkIsIIFE(definition)) {
    definition = resolveToValue(resolveIIFE(definition));
    if (!isComponentDefinition(definition)) {
      definition = resolveTranspiledClass(definition);
    }
  } else {
    definition = resolveToValue(resolveHOC(definition));
    if (isComponentDefinition(definition)) {
      definition = makeProxy(definition, {
        __meta: exportMeta,
      });
      return definition;
    }
    if (checkIsIIFE(definition)) {
      definition = resolveToValue(resolveIIFE(definition));
      if (!isComponentDefinition(definition)) {
        definition = resolveTranspiledClass(definition);
      }
    } else if (t.SequenceExpression.check(definition.node)) {
      const classNameNode = definition.parent.get('id').node;
      const localNames: string[] = [];
      let { node } = definition.get('expressions', 0);
      while (t.AssignmentExpression.check(node)) {
        // @ts-ignore
        const { name } = node.left;
        if (name) {
          localNames.push(name);
        }
        node = node.right;
      }
      definition.get('expressions').each((x: any) => {
        if (!x.name) return;
        if (t.AssignmentExpression.check(x.node) && t.MemberExpression.check(x.node.left)) {
          const objectName = x.node.left.object.name;
          if (localNames.includes(objectName)) {
            x.get('left', 'object').replace(classNameNode);
          }
        }
      });
      definition = getDefinition(resolveToValue(definition.get('expressions').get(0)), cache);
    } else {
      return resolveImport(definition, (ast: any, sourcePath: string, importMeta, mode) => {
        let result;
        if (has('ast-export', ast.__path)) {
          result = get('ast-export', ast.__path);
        } else {
          result = findAllExportedComponentDefinition(ast);
          set('ast-export', ast.__path, result);
        }

        const exportList: any[] = [];
        const importList: any[] = [];
        result.forEach((def: any) => {
          const { __meta: meta = {} } = def;
          let { exportName } = meta;
          for (const item of importMeta) {
            if (exportName === item.importedName) {
              exportName = item.localName;
              break;
            }
          }

          if (exportName) {
            importList.push(makeProxy(def, { __meta: { exportName } }));
          }

          const nextMeta: any = {
            exportName,
          };

          if (exportName === exportMeta.localName) {
            nextMeta.exportName = exportMeta.exportName;
          } else if (mode === 'import') {
            // } else {
            return;
          }

          if (exportMeta.subName) {
            nextMeta.subName = exportMeta.subName;
          } else if (meta.subName) {
            nextMeta.subName = meta.subName;
          }
          exportList.push(makeProxy(def, { __meta: nextMeta }));
        });
        cache[sourcePath] = importList;

        // result = result.filter((x) => !x.__shouldDelete);
        return exportList;
      });
    }
  }
  if (definition && (!definition.__meta || Object.keys(definition.__meta).length === 0)) {
    definition.__meta = exportMeta;
  }
  return definition;
}