export async function parseManifest()

in packages/plugin-pha/src/manifestHelpers.ts [324:427]
86 lines of code
33 McCabe index (conditional complexity)

export async function parseManifest(manifest: Manifest, options: ParseOptions): Promise<PHAManifest> {
  const {
    publicPath,
    dataloaderConfig,
    routeManifest,
  } = options;
  const { appWorker, tabBar, routes } = manifest;

  if (appWorker?.url && !appWorker.url.startsWith('http')) {
    appWorker.url = `${publicPath}${appWorker.url}`;
  }

  if (tabBar?.source && validateSource(tabBar.source, 'tabBar')) {
    if (!tabBar.url) {
      manifest.tabBar = {
        ...tabBar,
        ...(await getTabConfig(tabBar, false, options)),
      };
    }
    // Remove tab_bar.source because pha manifest do not recognize it.
    delete manifest.tabBar.source;
  }
  // items is `undefined` will crash in PHA and it is not supported to config list.
  if (tabBar && !tabBar.items) {
    tabBar.items = [];
  }

  if (routes && routes.length > 0) {
    manifest.pages = await Promise.all(routes.map(async (page) => {
      const pageIds = getRouteIdByPage(routeManifest, page);
      const pageManifest = await getPageManifest(page, options);

      // The manifest configuration is the default value for the page configuration.
      pageDefaultValueKeys.forEach(key => {
        if (!(key in pageManifest) && (key in manifest)) {
          pageManifest[key] = manifest[key];
        }
      });

      // Set static dataloader to data_prefetch of page.
      pageIds.forEach((pageId) => {
        if (typeof page === 'string' && dataloaderConfig && dataloaderConfig[pageId] && dataloaderConfig[pageId].loader) {
          const staticDataLoaders = [];
          const { loader } = dataloaderConfig[pageId];
          if (Array.isArray(loader)) {
            dataloaderConfig[pageId].loader.forEach(item => {
              if (typeof item === 'object') {
                staticDataLoaders.push(item);
              }
            });
          } else if (typeof loader === 'object') {
            // Single prefetch loader config.
            staticDataLoaders.push(loader);
          }
          pageManifest.dataPrefetch = [...(pageManifest.dataPrefetch || []), ...staticDataLoaders];
        }
      });

      if (pageManifest.frames && pageManifest.frames.length > 0) {
        pageManifest.frames = await Promise.all(pageManifest.frames.map((frame) => getPageManifest(frame, options)));
        // Set static dataloader to dataPrefetch of frames.
        pageManifest.frames.forEach((frame: Frame) => {
          if (typeof frame === 'string') return;
          const title = frame.title || '';
          const titleIds = getRouteIdByPage(routeManifest, title);
          titleIds.forEach((titleId) => {
            if (dataloaderConfig && dataloaderConfig[titleId] && dataloaderConfig[titleId].loader) {
              const staticDataLoaders = [];
              const { loader } = dataloaderConfig[titleId];
              if (Array.isArray(loader)) {
                loader.forEach(item => {
                  if (typeof item === 'object') {
                    staticDataLoaders.push(item);
                  }
                });
              } else if (typeof loader === 'object') {
                // Single prefetch loader config.
                staticDataLoaders.push(loader);
              }

              frame.dataPrefetch = [...(frame.dataPrefetch || []), ...staticDataLoaders];
            }
          });
        });
      }

      if (pageManifest?.pageHeader?.source) {
        if (!pageManifest.pageHeader.url) {
          pageManifest.pageHeader = {
            ...pageManifest.pageHeader,
            // Generate document logic is different from tabBar.
            ...(await getTabConfig(pageManifest.pageHeader, true, options)),
          };
        }
        delete pageManifest.pageHeader.source;
      }
      return pageManifest;
    }));
    // Delete manifest routes after transform.
    delete manifest.routes;
  }

  return transformManifestKeys(manifest, { isRoot: true });
}