export async function execute()

in modules/builders/src/static-generator/index.ts [36:105]
59 lines of code
7 McCabe index (conditional complexity)

export async function execute(
  options: PrerenderBuilderOptions,
  context: BuilderContext,
): Promise<BuilderOutput> {
  const browserTarget = targetFromTargetString(options.browserTarget);
  const browserOptions = (await context.getTargetOptions(
    browserTarget,
  )) as unknown as BrowserBuilderOptions;
  const routes = await getRoutes(options, browserOptions.tsConfig, context);

  if (!routes.length) {
    throw new Error(`Could not find any routes to generate.`);
  }

  const { result } = await context.scheduleTarget(browserTarget, {
    watch: false,
    serviceWorker: false,
  });

  const { success, error, outputPaths } = (await result) as BrowserBuilderOutput;
  if (!success) {
    return { success, error } as BuilderOutput;
  }

  const { styles: normalizedStylesOptimization } = normalizeOptimization(
    browserOptions.optimization,
  );

  const worker = createWorker();
  try {
    for (const outputPath of outputPaths) {
      const spinner = ora(`Prerendering ${routes.length} route(s) to ${outputPath}...`).start();

      const staticServer = await createStaticServer(outputPath);
      try {
        await Promise.all(
          routes.map((route) => {
            const options: RenderOptions = {
              inlineCriticalCss: normalizedStylesOptimization.inlineCritical,
              outputPath,
              route,
              port: staticServer.port,
            };

            return worker.run(options, { name: 'render' });
          }),
        );

        spinner.succeed(`Prerendering routes to ${outputPath} complete.`);

        if (browserOptions.serviceWorker) {
          const swResult = await generateServiceWorker(context, outputPath, browserOptions);
          if (!swResult.success) {
            return swResult;
          }
        }
      } catch (error) {
        spinner.fail(`Prerendering routes to ${outputPath} failed.`);

        return { success: false, error: error.message };
      } finally {
        await staticServer.close();
      }
    }

    return { success: true };
  } finally {
    void worker.destroy();
  }
}