Manifest Plugins

Copyexport default class BuildManifestPlugin {
  private buildId: string
  private rewrites: CustomRoutes['rewrites']
  private isDevFallback: boolean
  private appDirEnabled: boolean
  private clientRouterFilters?: Parameters<typeof generateClientManifest>[2]
// ...

Copy  apply(compiler: webpack.Compiler) {
    compiler.hooks.make.tap('NextJsBuildManifest', (compilation: any) => {
      compilation.hooks.processAssets.tap(
        {
          name: 'NextJsBuildManifest',
          stage: webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS,
        },
        () => {
          this.createAssets(compiler, compilation)
        }
      )
    })
    return
  }

Copyexport function getEntrypointFiles(entrypoint: any): string[] {
  return (
    entrypoint
      ?.getFiles()
      .filter((file: string) => {
        // We don't want to include `.hot-update.js` files into the initial page
        return /(?<!\.hot-update)\.(js|css)($|\?)/.test(file)
      })
      .map((file: string) => file.replace(/\\/g, '/')) ?? []
  )
}

Copyexport function generateClientManifest(
  assetMap: BuildManifest,
  rewrites: CustomRoutes['rewrites'],
  clientRouterFilters?: {
    staticFilter: ReturnType<BloomFilter['export']>
    dynamicFilter: ReturnType<BloomFilter['export']>
  },
  compiler?: any,
  compilation?: any
): string | undefined {
// ...

Copyexport const processRoute = (r: Rewrite) => {
  const rewrite = { ...r }
 
  // omit external rewrite destinations since these aren't
  // handled client-side
  if (!rewrite?.destination?.startsWith('/')) {
    delete (rewrite as any).destination
  }
  return rewrite
}

Copyconst pluginState = getProxiedPluginState({
  ssrModules: {} as { [ssrModuleId: string]: ModuleInfo },
  edgeSsrModules: {} as { [ssrModuleId: string]: ModuleInfo },
 
  rscModules: {} as { [rscModuleId: string]: ModuleInfo },
  edgeRscModules: {} as { [rscModuleId: string]: ModuleInfo },
})

Copyconst pluginState = getProxiedPluginState({
  // A map to track "action" -> "list of bundles".
  serverActions: {} as ActionManifest['node'],
  edgeServerActions: {} as ActionManifest['edge'],
 
  serverActionModules: {} as {
    [workerName: string]: {
      server?: ModuleInfo
      client?: ModuleInfo
    }
  },
 
  edgeServerActionModules: {} as {
    [workerName: string]: {
      server?: ModuleInfo
      client?: ModuleInfo
    }
  },
 
  ssrModules: {} as { [ssrModuleId: string]: ModuleInfo },
  edgeSsrModules: {} as { [ssrModuleId: string]: ModuleInfo },
 
  rscModules: {} as { [rscModuleId: string]: ModuleInfo },
  edgeRscModules: {} as { [rscModuleId: string]: ModuleInfo },
 
  injectedClientEntries: {} as Record<string, string>,
})

Copyexport interface ManifestNode {
  [moduleExport: string]: {
    id: ModuleId
    name: string
    chunks: ManifestChunks
    async?: boolean
  }
}
 
export interface ClientReferenceManifestForRsc {
  clientModules: ManifestNode
  rscModuleMapping: {
    [moduleId: string]: ManifestNode
  }
  edgeRscModuleMapping: {
    [moduleId: string]: ManifestNode
  }
}

Copyfunction entryNameToGroupName(entryName: string) {
  let groupName = entryName
    .slice(0, entryName.lastIndexOf('/'))
    // Remove slots
    .replace(/\/@[^/]+/g, '')
    // Remove the group with lookahead to make sure it's not interception route
    .replace(/\/\([^/]+\)(?=(\/|$))/g, '')
    // Remove catch-all routes since they should be part of the parent group that the catch-all would apply to.
    // This is necessary to support parallel routes since multiple page components can be rendered on the same page.
    // In order to do that, we need to ensure that the manifests are merged together by putting them in the same group.
    .replace(/\/\[?\[\.\.\.[^\]]*]]?/g, '')
 
  // Interception routes
  groupName = groupName
    .replace(/^.+\/\(\.\.\.\)/g, 'app/')
    .replace(/\/\(\.\)/g, '/')
 
  // Interception routes (recursive)
  while (/\/[^/]+\/\(\.\.\)/.test(groupName)) {
    groupName = groupName.replace(/\/[^/]+\/\(\.\.\)/g, '/')
  }
 
  return groupName
}

Copyapply(compiler: webpack.Compiler): void {
  compiler.hooks.make.tap('NextJsPagesManifest', (compilation) => {
    compilation.hooks.processAssets.tapPromise(
      {
        name: 'NextJsPagesManifest',
        stage: webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS,
      },
      () => this.createAssets(compilation)
    )
  })
}

Copyasync createAssets(compilation: any) {
  const entrypoints = compilation.entrypoints
  const pages: PagesManifest = {}
  const appPaths: PagesManifest = {}
 
  for (const entrypoint of entrypoints.values()) {
    const pagePath = getRouteFromEntrypoint(
      entrypoint.name,
      this.appDirEnabled
    )
 
    if (!pagePath) {
      continue
    }
 
    const files = entrypoint
      .getFiles()
      .filter(
        (file: string) =>
          !file.includes('webpack-runtime') &&
          !file.includes('webpack-api-runtime') &&
          file.endsWith('.js')
      )
 
    // Skip entries which are empty
    if (!files.length) {
      continue
    }

Copyexport let edgeServerPages = {}
export let nodeServerPages = {}
export let edgeServerAppPaths = {}
export let nodeServerAppPaths = {}

Copy// handle parallel compilers writing to the same
// manifest path by merging existing manifest with new
const writeMergedManifest = async (
  manifestPath: string,
  entries: Record<string, string>
) => {
  await fs.mkdir(path.dirname(manifestPath), { recursive: true })
  await fs.writeFile(
    manifestPath,
    JSON.stringify(
      {
        ...(await fs
          .readFile(manifestPath, 'utf8')
          .then((res) => JSON.parse(res))
          .catch(() => ({}))),
        ...entries,
      },
      null,
      2
    )
  )
}

Copyexport class NextFontManifestPlugin {
  private appDir: undefined | string
 
  constructor(options: { appDir: undefined | string }) {
    this.appDir = options.appDir
  }
 
  apply(compiler: webpack.Compiler) {
    compiler.hooks.make.tap(PLUGIN_NAME, (compilation) => {
      // In this stage the font files are emitted and we can collect all files emitted by each chunkGroup (entry).
      compilation.hooks.processAssets.tap(
        {
          name: PLUGIN_NAME,
          stage: webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS,
        },
        () => {
          const nextFontManifest: NextFontManifest = {
            pages: {},
            app: {},
            appUsingSizeAdjust: false,
            pagesUsingSizeAdjust: false,
          }

Copyif (this.appDir) {
  const appDirBase = path.dirname(this.appDir) + path.sep
 
  // After all modules are created, we collect the modules that was created by next-font-loader.
  traverseModules(
    compilation,
    (mod, _chunk, chunkGroup) => {
      if (mod?.request?.includes('/next-font-loader/index.js?')) {
        if (!mod.buildInfo?.assets) return
 
        const chunkEntryName = (appDirBase + chunkGroup.name).replace(
          /[\\/]/g,
          path.sep
        )
 
        const modAssets = Object.keys(mod.buildInfo.assets)
        const fontFiles: string[] = modAssets.filter((file: string) =>
          /\.(woff|woff2|eot|ttf|otf)$/.test(file)
        )
 
        // Look if size-adjust fallback font is being used
        if (!nextFontManifest.appUsingSizeAdjust) {
          nextFontManifest.appUsingSizeAdjust =
            getPageIsUsingSizeAdjust(fontFiles)
        }
 
        const preloadedFontFiles = getPreloadedFontFiles(fontFiles)
 
        // Add an entry of the module's font files in the manifest.
        // We'll add an entry even if no files should preload.
        // When an entry is present but empty, instead of preloading the font files, a preconnect tag is added.
        if (fontFiles.length > 0) {
          if (!nextFontManifest.app[chunkEntryName]) {
            nextFontManifest.app[chunkEntryName] = []
          }
          nextFontManifest.app[chunkEntryName].push(
            ...preloadedFontFiles
          )
        }
      }
    },
    (chunkGroup) => {
      // Only loop through entrypoints that are under app/.
      return !!chunkGroup.name?.startsWith('app/')
    }
  )
}
 
// Look at all the entrypoints created for pages/.
for (const entrypoint of compilation.entrypoints.values()) {
  const pagePath = getRouteFromEntrypoint(entrypoint.name!)
 
  if (!pagePath) {
    continue
  }
 
  // Get font files from the chunks included in the entrypoint.
  const fontFiles: string[] = entrypoint.chunks
    .flatMap((chunk: any) => [...chunk.auxiliaryFiles])
    .filter((file: string) =>
      /\.(woff|woff2|eot|ttf|otf)$/.test(file)
    )
 
  // Look if size-adjust fallback font is being used
  if (!nextFontManifest.pagesUsingSizeAdjust) {
    nextFontManifest.pagesUsingSizeAdjust =
      getPageIsUsingSizeAdjust(fontFiles)
  }
 
  const preloadedFontFiles = getPreloadedFontFiles(fontFiles)
 
  // Add an entry of the route's font files in the manifest.
  // We'll add an entry even if no files should preload.
  // When an entry is present but empty, instead of preloading the font files, a preconnect tag is added.
  if (fontFiles.length > 0) {
    nextFontManifest.pages[pagePath] = preloadedFontFiles
  }
}

Copyexport type NextFontManifest = {
  pages: {
    [path: string]: string[]
  }
  app: {
    [entry: string]: string[]
  }
  appUsingSizeAdjust: boolean
  pagesUsingSizeAdjust: boolean
}

Copy  const manifest = JSON.stringify(nextFontManifest, null)
  // Create manifest for edge
  compilation.emitAsset(
    `server/${NEXT_FONT_MANIFEST}.js`,
    new sources.RawSource(
      `self.__NEXT_FONT_MANIFEST=${JSON.stringify(manifest)}`
    ) as unknown as webpack.sources.RawSource
  )
 
  // Create manifest for server
  compilation.emitAsset(
    `server/${NEXT_FONT_MANIFEST}.json`,
    new sources.RawSource(
      manifest
    ) as unknown as webpack.sources.RawSource
  )
}

Copyapply(compiler: webpack.Compiler) {
  compiler.hooks.make.tap('ReactLoadableManifest', (compilation) => {
    compilation.hooks.processAssets.tap(
      {
        name: 'ReactLoadableManifest',
        stage: webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS,
      },
      () => {
        this.createAssets(compiler, compilation)
      }
    )
  })
}

Copy// Find all dependencies blocks which contains a `import()` dependency
const handleBlock = (block: any) => {
  block.blocks.forEach(handleBlock)
  const chunkGroup = getChunkGroupFromBlock(compilation, block)
  for (const dependency of block.dependencies) {
    if (dependency.type.startsWith('import()')) {

Copy// get the module containing the import()
const originModule = getOriginModuleFromDependency(
  compilation,
  dependency
)
const originRequest: string | undefined = originModule?.resource
if (!originRequest) return
 
// We construct a "unique" key from origin module and request
// It's not perfect unique, but that will be fine for us.
// We also need to construct the same in the babel plugin.
const key = `${path.relative(projectSrcDir, originRequest)} -> ${
  dependency.request
}`

Copyif (chunkGroup) {
  for (const chunk of (chunkGroup as any)
    .chunks as webpack.Compilation['chunks']) {
    chunk.files.forEach((file: string) => {
      if (
        (file.endsWith('.js') || file.endsWith('.css')) &&
        file.match(/^static\/(chunks|css)\//)
      ) {
        files.add(file)
 
        if (shouldCreateDynamicCssManifest && file.endsWith('.css')) {
          dynamicCssManifestSet.add(file)
        }
      }
    })
  }
}

Copyconst matcherSource = metadata.edgeSSR?.isAppDir
  ? normalizeAppPath(page)
  : page
 
const catchAll = !metadata.edgeSSR && !metadata.edgeApiFunction
 
const { namedRegex } = getNamedMiddlewareRegex(matcherSource, {
  catchAll,
})
const matchers = metadata?.edgeMiddleware?.matchers ?? [
  {
    regexp: namedRegex,
    originalSource: page === '/' && catchAll ? '/:path*' : matcherSource,
  },
]

Copywasm: Array.from(metadata.wasmBindings, ([name, filePath]) => ({
  name,
  filePath,
})),
assets: Array.from(metadata.assetBindings, ([name, filePath]) => ({
  name,
  filePath,
})),

Copyfunction registerUnsupportedApiHooks(
  parser: webpack.javascript.JavascriptParser,
  compilation: webpack.Compilation
) {
  for (const expression of EDGE_UNSUPPORTED_NODE_APIS) {
    const warnForUnsupportedApi = (node: any) => {
      if (!isInMiddlewareLayer(parser)) {
        return
      }
      compilation.warnings.push(
        buildUnsupportedApiError({
          compilation,
          parser,
          apiName: expression,
          ...node,
        })
      )
      return true
    }
    parser.hooks.call.for(expression).tap(NAME, warnForUnsupportedApi)
    parser.hooks.expression.for(expression).tap(NAME, warnForUnsupportedApi)
    parser.hooks.callMemberChain
      .for(expression)
      .tap(NAME, warnForUnsupportedApi)
    parser.hooks.expressionMemberChain
      .for(expression)
      .tap(NAME, warnForUnsupportedApi)
  }

Copyfunction isDynamicCodeEvaluationAllowed(
  fileName: string,
  middlewareConfig?: ProxyConfig,
  rootDir?: string
) {
  // Some packages are known to use `eval` but are safe to use in the Edge
  // Runtime because the dynamic code will never be executed.
  if (
    KNOWN_SAFE_DYNAMIC_PACKAGES.some((pkg) =>
      fileName.includes(`/node_modules/${pkg}/`.replace(/\//g, path.sep))
    )
  ) {
    return true
  }
 
  const name = fileName.replace(rootDir ?? '', '')
 
  return picomatch(middlewareConfig?.unstable_allowDynamic ?? [], {
    dot: true,
  })(name)
}