Function build

packages/nuxt/src/core/builder.ts:14–110

(nuxt: Nuxt)

import type { Nuxt, NuxtBuilder, NuxtHooks } from 'nuxt/schema'

export async function build (nuxt: Nuxt): Promise<void> {
  nuxt._perf?.startPhase('app:generate')
  const app = createApp(nuxt)
  nuxt.apps.default = app

  let closing = false
  const writes = new Set<Promise<unknown>>()
  const track = async <T> (run: () => Promise<T>) => {
    if (closing) { return }
    const p = run()
    writes.add(p)
    try { await p } finally { writes.delete(p) }
  }
  const generateApp = debounce(() => _generateApp(nuxt, app), undefined, { leading: true })
  await generateApp()
  nuxt._perf?.endPhase('app:generate')

  if (nuxt.options.dev) {
    watch(nuxt)
    nuxt.hook('close', async () => {
      closing = true
      generateApp.cancel()
      await Promise.allSettled(writes)
    })
    nuxt.hook('builder:watch', async (event, relativePath) => {
      // Unset mainComponent and errorComponent if app or error component is changed
      if (event === 'add' || event === 'unlink') {
        const path = resolve(nuxt.options.srcDir, relativePath)
        for (const dirs of getLayerDirectories(nuxt)) {
          const relativePath = relative(dirs.app, path)
          if (/^app\./i.test(relativePath)) {
            app.mainComponent = undefined
            break
          }
          if (/^error\./i.test(relativePath)) {
            app.errorComponent = undefined
            break
          }
        }
      }

      // Recompile app templates
      await track(() => generateApp())
    })
    nuxt.hook('builder:generateApp', (options) => {
      // Bypass debounce if we are selectively invalidating templates
      if (options) { return track(() => _generateApp(nuxt, app, options)) }
      return track(() => generateApp())
    })
  }

  if (!nuxt.options._prepare && !nuxt.options.dev && nuxt.options.experimental.buildCache) {
    const { restoreCache, collectCache } = await getVueHash(nuxt)
    if (await restoreCache()) {
      await nuxt.callHook('build:done')
      await nuxt.callHook('close', nuxt)
      return
    }