Webpack Loaders

Copyconst loaderOptions = this.getOptions()
const {
  name,
  appDir,
  appPaths,
  allNormalizedAppPaths: allNormalizedAppPathsOption,
  pagePath,
  pageExtensions,
  rootDir,
  tsconfigPath,
  isDev,
  nextConfigOutput,
  preferredRegion,
  basePath,
  middlewareConfig: middlewareConfigBase64,
} = loaderOptions
 
const isGlobalNotFoundEnabled = !!loaderOptions.isGlobalNotFoundEnabled
const explicitParallelRouteChildren =
  !!loaderOptions.explicitParallelRouteChildren
const strictRouteMatching = !!loaderOptions.strictRouteMatching
const isFinalRouteMatcher = !!loaderOptions.isFinalRouteMatcher
 
// Update FILE_TYPES on the very top-level of the loader
if (!isGlobalNotFoundEnabled) {
  // @ts-expect-error this delete is only necessary while experimental
  delete FILE_TYPES['global-not-found']
}
 
const buildInfo = getModuleBuildInfo((this as any)._module)
const collectedDeclarations: [string, string][] = []
 
// Use the page from loaderOptions directly instead of deriving it from name.
// The name (bundlePath) may have been normalized with normalizePagePath()
// which is designed for Pages Router and incorrectly duplicates /index paths
// (e.g., /index/page -> /index/index/page). The page parameter contains the
// correct unnormalized value.
const page = loaderOptions.page
 
const middlewareConfig: ProxyConfig = JSON.parse(
  Buffer.from(middlewareConfigBase64, 'base64').toString()
)
buildInfo.route = {
  page,
  absolutePagePath: createAbsolutePath(appDir, pagePath),
  preferredRegion,
  middlewareConfig,
  relatedModules: [],
}

Copyconst resolveParallelSegments = (
  pathname: string
): [string, string | string[]][] => {
  const matched: Record<string, string | string[]> = {}
  let existingChildrenPath: string | undefined
  for (const appPath of normalizedAppPaths) {
    if (appPath.startsWith(pathname + '/')) {
      const rest = appPath.slice(pathname.length + 1).split('/')
 
      // It is the actual page, mark it specially.
      if (rest.length === 1 && rest[0] === 'page') {
        existingChildrenPath = appPath
        matched.children = PAGE_SEGMENT
        continue
      }
 
      const isParallelRoute = rest[0].startsWith('@')
      if (isParallelRoute) {
        if (rest.length === 2 && rest[1] === 'page') {
          // We found a parallel route at this level. We don't want to mark it explicitly as the page segment,
          // as that should be matched to the `children` slot. Instead, we use an array, to signal to `createSubtreePropsFromSegmentPath`
          // that it needs to recursively fill in the loader tree code for the parallel route at the appropriate levels.
          matched[rest[0]] = [PAGE_SEGMENT]
          continue
        }
        // If it was a parallel route but we weren't able to find the page segment (ie, maybe the page is nested further)
        // we first insert a special marker to ensure that we still process layout/default/etc at the slot level prior to continuing
        // on to the page segment.
        matched[rest[0]] = [PARALLEL_VIRTUAL_SEGMENT, ...rest.slice(1)]
        continue
      }
 
      if (existingChildrenPath && matched.children !== rest[0]) {
        // If we get here, it means we already set a `page` segment earlier in the loop,
        // meaning we already matched a page to the `children` parallel segment.
        const isIncomingParallelPage = appPath.includes('@')
        const hasCurrentParallelPage = existingChildrenPath.includes('@')
 
        if (isIncomingParallelPage) {
          // The duplicate segment was for a parallel slot. In this case,
          // rather than throwing an error, we can ignore it since this can happen for valid reasons.
          // For example, when we attempt to normalize catch-all routes, we'll push potential slot matches so
          // that they are available in the loader tree when we go to render the page.
          // We only need to throw an error if the duplicate segment was for a regular page.
          // For example, /app/(groupa)/page & /app/(groupb)/page is an error since it corresponds
          // with the same path.
          continue
        } else if (!hasCurrentParallelPage && !isIncomingParallelPage) {
          // Both the current `children` and the incoming `children` are regular pages.
          throw new Error(
            `You cannot have two parallel pages that resolve to the same path. Please check ${existingChildrenPath} and ${appPath}. Refer to the route group docs for more information: https://nextjs.org/docs/app/building-your-application/routing/route-groups`
          )
        }
      }
 
      existingChildrenPath = appPath
      matched.children = rest[0]
    }
  }
 
  return Object.entries(matched)
}

Copyexport function getAssumedSourceType(
  mod: webpack.Module,
  sourceType: SourceType
): SourceType {
  const buildInfo = getModuleBuildInfo(mod)
  const detectedClientEntryType = buildInfo?.rsc?.clientEntryType
  const clientRefs = buildInfo?.rsc?.clientRefs || []
 
  // It's tricky to detect the type of a client boundary, but we should always
  // use the `module` type when we can, to support `export *` and `export from`
  // syntax in other modules that import this client boundary.
 
  if (sourceType === 'auto') {
    if (detectedClientEntryType === 'auto') {
      if (clientRefs.length === 0) {
        // If there's zero export detected in the client boundary, and it's the
        // `auto` type, we can safely assume it's a CJS module because it doesn't
        // have ESM exports.
        return 'commonjs'
      } else if (!clientRefs.includes('*')) {
        // Otherwise, we assume it's an ESM module.
        return 'module'
      }
    } else if (detectedClientEntryType === 'cjs') {
      return 'commonjs'
    }
  }
 
  return sourceType
}

Copy      let esmSource =
        prefix +
        `\
import { registerClientReference } from "react-server-dom-webpack/server";
`
      for (const ref of clientRefs) {
        if (ref === 'default') {
          esmSource += `export default registerClientReference(
function() { throw new Error(${JSON.stringify(`Attempted to call the default \
export of ${stringifiedResourceKey} from the server, but it's on the client. \
It's not possible to invoke a client function from the server, it can only be \
rendered as a Component or passed to props of a Client Component.`)}); },
${stringifiedResourceKey},
"default",
);\n`
        } else {
          esmSource += `export const ${ref} = registerClientReference(
function() { throw new Error(${JSON.stringify(`Attempted to call ${ref}() from \
the server but ${ref} is on the client. It's not possible to invoke a client \
function from the server, it can only be rendered as a Component or passed to \
props of a Client Component.`)}); },
${stringifiedResourceKey},
${JSON.stringify(ref)},
);`
        }
      }

Copyexport default function transformSource(
  this: webpack.LoaderContext<NextFlightClientEntryLoaderOptions>
) {
  let { modules, server } = this.getOptions()
  const isServer = server === 'true'
 
  if (!Array.isArray(modules)) {
    modules = modules ? [modules] : []
  }
 
  const code = modules
    .map((x) => JSON.parse(x) as FlightClientEntryModuleItem)
    // Filter out CSS files in the SSR compilation
    .filter(({ request }) => (isServer ? !regexCSS.test(request) : true))
    .map(({ request, ids }: FlightClientEntryModuleItem) => {
      const importPath = JSON.stringify(
        request.startsWith(BARREL_OPTIMIZATION_PREFIX)
          ? request.replace(':', '!=!')
          : request
      )
 
      // When we cannot determine the export names, we use eager mode to include the whole module.
      // Otherwise, we use eager mode with webpackExports to only include the necessary exports.
      // If we have '*' in the ids, we include all the imports
      if (ids.length === 0 || ids.includes('*')) {
        return `import(/* webpackMode: "eager" */ ${importPath});\n`
      } else {
        return `import(/* webpackMode: "eager", webpackExports: ${JSON.stringify(
          ids
        )} */ ${importPath});\n`
      }
    })
    .join(';\n')

Copyfunction nextFlightActionEntryLoader(
  this: webpack.LoaderContext<NextFlightActionEntryLoaderOptions>
) {
  const { actions }: NextFlightActionEntryLoaderOptions = this.getOptions()
 
  const actionList = JSON.parse(actions) as FlightActionEntryLoaderActions
  const individualActions = actionList
    .map(([path, actionsFromModule]) => {
      return actionsFromModule.map(({ id, exportedName }) => {
        return [id, path, exportedName] as const
      })
    })
    .flat()
 
  return `
${individualActions
  .map(([id, path, exportedName]) => {
    // Re-export the same functions from the original module path as action IDs.
    return `export { ${exportedName} as "${id}" } from ${JSON.stringify(path)}`
  })
  .join('\n')}
`
}

Copyasync function loaderTransform(
  this: LoaderContext<SWCLoaderOptions> & TelemetryLoaderContext,
  source?: string,
  inputSourceMap?: any
) {
  // Make the loader async
  const filename = this.resourcePath
 
  // Ensure `.d.ts` are not processed.
  if (filename.endsWith('.d.ts')) {
    return [source, inputSourceMap]
  }
 
  let loaderOptions: SWCLoaderOptions = this.getOptions() || {}
  const shouldMaybeExclude = maybeExclude(
    filename,
    loaderOptions.transpilePackages || []
  )
 
  const trackDynamicImports = shouldTrackDynamicImports(loaderOptions)
 
  if (shouldMaybeExclude) {
    if (!source) {
      throw new Error(`Invariant might be excluded but missing source`)
    }
 
    const forceTranspileConditions = trackDynamicImports
      ? FORCE_TRANSPILE_CONDITIONS_WITH_IMPORT
      : FORCE_TRANSPILE_CONDITIONS
 
    if (!forceTranspileConditions.test(source)) {
      return [source, inputSourceMap]
    }
  }

Copyexport async function eventSwcLoadFailure(
  event?: Pick<
    EventSwcLoadFailure['payload'],
    'wasm' | 'nativeBindingsErrorCode'
  >
): Promise<void> {
  const telemetry: Telemetry | undefined = traceGlobals.get('telemetry')
  // can't continue if telemetry isn't set
  if (!telemetry) return
 
  let glibcVersion
  let installedSwcPackages
 
  try {
    // @ts-ignore
    glibcVersion = process.report?.getReport().header.glibcVersionRuntime
  } catch {}
 
  try {
    const pkgNames = Object.keys(optionalDependencies || {}).filter((pkg) =>
      pkg.startsWith('@next/swc')
    )
    const installedPkgs = []
 
    for (const pkg of pkgNames) {
      try {
        const { version } = require(`${pkg}/package.json`)
        installedPkgs.push(`${pkg}@${version}`)
      } catch {}
    }
 
    if (installedPkgs.length > 0) {
      installedSwcPackages = installedPkgs.sort().join(',')
    }
  } catch {}
 
  telemetry.record({
    eventName: EVENT_PLUGIN_PRESENT,
    payload: {
      nextVersion: process.env.__NEXT_VERSION as string,
      glibcVersion,
      installedSwcPackages,
      arch: process.arch,
      platform: process.platform,
      nodeVersion: process.versions.node,
      wasm: event?.wasm,
      nativeBindingsErrorCode: event?.nativeBindingsErrorCode,
    },
  })
  // ensure this event is flushed before process exits
  await telemetry.flush()
}

Copytype RouteLoaderOptionsPagesAPIInput = {
  kind: RouteKind.PAGES_API
  page: string
  preferredRegion: string | string[] | undefined
  absolutePagePath: string
  middlewareConfig: ProxyConfig
}
 
type RouteLoaderOptionsPagesInput = {
  kind: RouteKind.PAGES
  page: string
  pages: MappedPages
  preferredRegion: string | string[] | undefined
  absolutePagePath: string
  middlewareConfig: ProxyConfig
}
 
type RouteLoaderOptionsInput =
  | RouteLoaderOptionsPagesInput
  | RouteLoaderOptionsPagesAPIInput
 

Copyfunction swapDistFolderWithEsmDistFolder(path: string) {
  return path.replace('next/dist/pages', 'next/dist/esm/pages')
}

Copyinterface CharacteristicsGermaneToCaching {
  isStandalone: boolean
  isServer: boolean | undefined
  isPageFile: boolean | undefined
  isNextDist: boolean
  hasModuleExports: boolean
  hasReactCompiler: boolean
  fileExt: string
  configFilePath: string | undefined
}

Copyfunction getCustomBabelConfig(configFilePath: string) {
  if (isJsonFile.exec(configFilePath)) {
    const babelConfigRaw = readFileSync(configFilePath, 'utf8')
    return JSON5.parse(babelConfigRaw)
  } else if (isJsFile.exec(configFilePath)) {
    return require(configFilePath)
  }
  throw new Error(
    'The Next.js Babel loader does not support .mjs or .cjs config files.'
  )
}

Copytry {
  const reactPkgPath = require.resolve('react/package.json', {
    paths: [cwd],
  })
  const majorVersion: string = require(reactPkgPath).version.split('.')[0]
  if (majorVersion === '18') {
    target = majorVersion
  }

Copyconst barrelTransformMappingCache = new Map<
  string,
  {
    exportList: [string, string, string][]
    wildcardExports: string[]
    isClientEntry: boolean
  } | null
>()

Copyif (!mapping) {
  // This file isn't a barrel and we can't apply any optimizations. Let's re-export everything.
  // Since this loader accepts `names` and the request is keyed with `names`, we can't simply
  // return the original source here. That will create these imports with different names as
  // different modules instances.
  this.callback(null, `export * from ${JSON.stringify(this.resourcePath)}`)
  return
}