function buildNav()

in docs_template/publish.js [385:576]
155 lines of code
22 McCabe index (conditional complexity)

function buildNav(members) {
  let globalNav;
  let nav = '<h2><a href="index.html">Home</a></h2>';
  const seen = {};
  const seenTutorials = {};

  const paths = new Set();
  Object.values(members).forEach(items => {
    items.forEach(item => {
      if (item.meta) {
        paths.add(item.meta.path);
      }
    });
  });
  const splitStrings = (a, sep = '/') => a.map(i => i.split(sep));
  const elAt = i => a => a[i];
  const rotate = a => a[0].map((e, i) => a.map(elAt(i)));
  const allElementsEqual = arr => arr.every(e => e === arr[0]);
  const commonPath = (input, sep = '/') =>
    `${rotate(splitStrings(input, sep))
      .filter(allElementsEqual)
      .map(elAt(0))
      .join(sep)}${sep}`;
  const capitalize = s => s.charAt(0).toUpperCase() + s.slice(1);
  const basePath = commonPath(Array.from(paths));
  const localPaths = Array.from(paths).map(each => each.replace(basePath, ''));
  const builds = [...new Set(localPaths.map(p => p.split('/')[0]))].sort();

  builds.forEach(buildName => {
    const modules = members.modules.filter(
      m =>
        m.meta && m.meta.path.replace(basePath, '').startsWith(`${buildName}`)
    );
    const externals = members.externals.filter(
      e =>
        e.meta && e.meta.path.replace(basePath, '').startsWith(`${buildName}`)
    );
    const namespaces = members.namespaces.filter(
      n =>
        n.meta && n.meta.path.replace(basePath, '').startsWith(`${buildName}`)
    );
    const classes = members.classes.filter(
      c =>
        c.meta && c.meta.path.replace(basePath, '').startsWith(`${buildName}`)
    );
    const interfaces = members.interfaces.filter(
      i =>
        i.meta && i.meta.path.replace(basePath, '').startsWith(`${buildName}`)
    );
    const events = members.events.filter(
      e =>
        e.meta && e.meta.path.replace(basePath, '').startsWith(`${buildName}`)
    );
    const mixins = members.mixins.filter(
      m =>
        m.meta && m.meta.path.replace(basePath, '').startsWith(`${buildName}`)
    );
    const globals = members.globals.filter(
      g =>
        g.meta && g.meta.path.replace(basePath, '').startsWith(`${buildName}`)
    );

    if (
      ![
        modules,
        externals,
        namespaces,
        classes,
        interfaces,
        events,
        mixins,
      ].some(a => a.length)
    ) {
      return;
    }

    nav += `<h2><span class="toggle opened"></span>${capitalize(
      buildName
    )}</h2><div class="content active"><ul>`;

    if (modules.length) {
      nav += `<li><ul><li class="node">${buildMemberNav(
        modules,
        'Modules',
        {},
        linkto
      )}</li></ul></li>`;
    }
    if (externals.length) {
      nav += `<li><ul><li class="node">${buildMemberNav(
        externals,
        'Externals',
        seen,
        linktoExternal
      )}</li></ul></li>`;
    }
    if (namespaces.length) {
      nav += `<li><ul><li class="node">${buildMemberNav(
        namespaces,
        'Namespaces',
        seen,
        linkto
      )}</li></ul></li>`;
    }
    if (classes.length) {
      nav += `<li><ul><li class="node">${buildMemberNav(
        classes,
        'Classes',
        seen,
        linkto
      )}</li></ul></li>`;
    }
    if (interfaces.length) {
      nav += `<li><ul><li class="node">${buildMemberNav(
        interfaces,
        'Interfaces',
        seen,
        linkto
      )}</li></ul></li>`;
    }
    if (events.length) {
      nav += `<li><ul><li class="node">${buildMemberNav(
        events,
        'Events',
        seen,
        linkto
      )}</li></ul></li>`;
    }
    if (mixins.length) {
      nav += `<li><ul><li class="node">${buildMemberNav(
        mixins,
        'Mixins',
        seen,
        linkto
      )}</li></ul></li>`;
    }

    if (globals.length) {
      globalNav = '';

      globals.forEach(({kind, longname, name}) => {
        if (kind !== 'typedef' && !hasOwnProp.call(seen, longname)) {
          globalNav += `<li>${linkto(longname, name)}</li>`;
        }
        seen[longname] = true;
      });

      if (!globalNav) {
        // turn the heading into a link so you can actually get to the global page
        nav += `<h3>${linkto('global', 'Global')}</h3>`;
      } else {
        nav += `<h3>Global</h3><ul>${globalNav}</ul>`;
      }
    }

    nav += '</ul></div>';
  });

  /*nav += buildMemberNav(members.modules, 'Modules', {}, linkto);
  nav += buildMemberNav(members.externals, 'Externals', seen, linktoExternal);
  nav += buildMemberNav(members.namespaces, 'Namespaces', seen, linkto);
  nav += buildMemberNav(members.classes, 'Classes', seen, linkto);
  nav += buildMemberNav(members.interfaces, 'Interfaces', seen, linkto);
  nav += buildMemberNav(members.events, 'Events', seen, linkto);
  nav += buildMemberNav(members.mixins, 'Mixins', seen, linkto);*/
  nav += buildMemberNav(
    members.tutorials,
    'Tutorials',
    seenTutorials,
    linktoTutorial
  );

  /*if (members.globals.length) {
    globalNav = '';

    members.globals.forEach(({kind, longname, name}) => {
      if (kind !== 'typedef' && !hasOwnProp.call(seen, longname)) {
        globalNav += `<li>${linkto(longname, name)}</li>`;
      }
      seen[longname] = true;
    });

    if (!globalNav) {
      // turn the heading into a link so you can actually get to the global page
      nav += `<h3>${linkto('global', 'Global')}</h3>`;
    } else {
      nav += `<h3>Global</h3><ul>${globalNav}</ul>`;
    }
  }*/

  return nav;
}