Webpack Configuration

Copyif (dev) {
  const nextDistPath = 'next/dist/' + (isEdgeServer ? 'esm/' : '')
  customAppAliases[`${PAGES_DIR_ALIAS}/_app`] = [
    ...(pagesDir
      ? pageExtensions.reduce((prev, ext) => {
          prev.push(path.join(pagesDir, `_app.${ext}`))
          return prev
        }, [] as string[])
      : []),
    `${nextDistPath}pages/_app.js`,
  ]
  customAppAliases[`${PAGES_DIR_ALIAS}/_error`] = [
    ...(pagesDir
      ? pageExtensions.reduce((prev, ext) => {
          prev.push(path.join(pagesDir, `_error.${ext}`))
          return prev
        }, [] as string[])
      : []),
    `${nextDistPath}pages/_error.js`,
  ]
  customDocumentAliases[`${PAGES_DIR_ALIAS}/_document`] = [
    ...(pagesDir
      ? pageExtensions.reduce((prev, ext) => {
          prev.push(path.join(pagesDir, `_document.${ext}`))
          return prev
        }, [] as string[])
      : []),
    `${nextDistPath}pages/_document.js`,
  ]
}

Copyexport function createVendoredReactAliases(
  bundledReactChannel: BundledReactChannel,
  {
    layer,
    isBrowser,
    isEdgeServer,
    reactProductionProfiling,
  }: {
    layer: WebpackLayerName
    isBrowser: boolean
    isEdgeServer: boolean
    reactProductionProfiling: boolean
  }
): CompilerAliases {
  const environmentCondition = isBrowser
    ? 'browser'
    : isEdgeServer
      ? 'edge'
      : 'nodejs'
  const reactCondition = shouldUseReactServerCondition(layer)
    ? 'server'
    : 'client'
 
  // ✅ Correct alias

Copyexport async function lazyPostCSS(
  rootDirectory: string,
  supportedBrowsers: string[] | undefined,
  disablePostcssPresetEnv: boolean | undefined,
  useLightningcss: boolean | undefined
) {
  if (!postcssInstancePromise) {
    postcssInstancePromise = (async () => {
      const postcss = require('postcss') as typeof import('postcss').default
      // @ts-ignore backwards compat
      postcss.plugin = function postcssPlugin(name, initializer) {
        function creator(...args: any) {
          let transformer = initializer(...args)
          transformer.postcssPlugin = name
          // transformer.postcssVersion = new Processor().version
          return transformer
        }
 
        let cache: any
        Object.defineProperty(creator, 'postcss', {
          get() {
            if (!cache) cache = creator()
            return cache
          },
        })
 
        creator.process = function (
          css: any,
          processOpts: any,
          pluginOpts: any
        ) {
          return postcss([creator(pluginOpts)]).process(css, processOpts)
        }
 
        return creator
      }
 
      // @ts-ignore backwards compat
      postcss.vendor = {
        /**
         * Returns the vendor prefix extracted from an input string.
         *
         * @example
         * postcss.vendor.prefix('-moz-tab-size') //=> '-moz-'
         * postcss.vendor.prefix('tab-size')      //=> ''
         */
        prefix: function prefix(prop: string): string {
          const match = prop.match(/^(-\w+-)/)
 
          if (match) {
            return match[0]
          }
 
          return ''
        },
 
        /**
         * Returns the input string stripped of its vendor prefix.
         *
         * @example
         * postcss.vendor.unprefixed('-moz-tab-size') //=> 'tab-size'
         */
        unprefixed: function unprefixed(
          /**
           * String with or without vendor prefix.
           */
          prop: string
        ): string {
          return prop.replace(/^-\w+-/, '')
        },
      }

Copyexport function getRspackCore() {
  warnRspack()
  try {
    // eslint-disable-next-line @next/internal/typechecked-require
    return require('next-rspack/rspack-core')
  } catch (e) {
    if (e instanceof Error && 'code' in e && e.code === 'MODULE_NOT_FOUND') {
      throw new Error(
        '@rspack/core is not available. Please make sure `next-rspack` is correctly installed.'
      )
    }
 
    throw e
  }
}

Copyexport function getNextFontLoader(
  ctx: ConfigurationContext,
  postcss: any,
  fontLoaderPath: string
): webpack.RuleSetUseItem[] {
  const loaders: webpack.RuleSetUseItem[] = []
 
  if (ctx.isClient) {
    // Add appropriate development mode or production mode style
    // loader
    loaders.push(
      getClientStyleLoader({
        hasAppDir: ctx.hasAppDir,
        isDevelopment: ctx.isDevelopment,
        assetPrefix: ctx.assetPrefix,
      })
    )
  }
 
  loaders.push({
    loader: require.resolve('../../../../loaders/css-loader/src'),
    options: {
      postcss,
      importLoaders: 1,
      // Use CJS mode for backwards compatibility:
      esModule: false,
      url: (url: string, resourcePath: string) =>
        cssFileResolve(url, resourcePath, ctx.experimental.urlImports),
      import: (url: string, _: any, resourcePath: string) =>
        cssFileResolve(url, resourcePath, ctx.experimental.urlImports),
      modules: {
        // Do not transform class names (CJS mode backwards compatibility):
        exportLocalsConvention: 'asIs',
        // Server-side (Node.js) rendering support:
        exportOnlyLocals: ctx.isServer,
        // Disallow global style exports so we can code-split CSS and
        // not worry about loading order.
        mode: 'pure',
        getLocalIdent: (
          _context: any,
          _localIdentName: any,
          exportName: string,
          _options: any,
          meta: any
        ) => {
          // hash from next-font-loader
          return `__${exportName}_${meta.fontFamilyHash}`
        },
      },
      fontLoader: true,
    },
  })
 
  loaders.push({
    loader: 'next-font-loader',
    options: {
      isDev: ctx.isDevelopment,
      isServer: ctx.isServer,
      assetPrefix: ctx.assetPrefix,
      deploymentId: ctx.deploymentId,
      fontLoaderPath,
      postcss,
    },
  })
 
  return loaders

Copyexport const css: (
  ctx: ConfigurationContext
) => (config: webpack.Configuration) => Promise<webpack.Configuration> = curry(
  async function css(ctx: ConfigurationContext, config: webpack.Configuration) {

Copy...(isEdgeServer
  ? [
      {
        '@builder.io/partytown': '{}',
        'next/dist/compiled/etag': '{}',
      },
      getEdgePolyfilledModules(),
      handleWebpackExternalForEdgeRuntime,
    ]

Copyconst KNOWN_SAFE_DYNAMIC_PACKAGES =
  require('../../../lib/known-edge-safe-packages.json') as string[]
 

Copyconst webpack = require('@rspack/core')
const path = require('path')
const { BundleAnalyzerPlugin } = require('webpack-bundle-analyzer')
const DevToolsIgnoreListPlugin = require('./webpack-plugins/devtools-ignore-list-plugin')

Copyconst path = require('path')
const webpack = require('@rspack/core')
const MODERN_BROWSERSLIST_TARGET = require('./src/shared/lib/modern-browserslist-target')
const DevToolsIgnoreListPlugin = require('./webpack-plugins/devtools-ignore-list-plugin')

Copyexport function loadWebpackHook(webpackProjectDir: string) {
  if (installed) {
    return
  }
  installed = true
 
  const requireHook =
    require('../server/require-hook') as typeof import('../server/require-hook')
  const customWebpack = Boolean(process.env.NEXT_PRIVATE_LOCAL_WEBPACK)
  if (customWebpack) {

Copyconst webpackAliases: [string, string][] = [
  ['webpack', 'next/dist/compiled/webpack/webpack-lib'],
  ['webpack/package', 'next/dist/compiled/webpack/package'],
  ['webpack/package.json', 'next/dist/compiled/webpack/package'],
  ['webpack/lib/webpack', 'next/dist/compiled/webpack/webpack-lib'],
  ['webpack/lib/webpack.js', 'next/dist/compiled/webpack/webpack-lib'],
  [
    'webpack/lib/node/NodeEnvironmentPlugin',
    'next/dist/compiled/webpack/NodeEnvironmentPlugin',
  ],
  [
    'webpack/lib/node/NodeEnvironmentPlugin.js',
    'next/dist/compiled/webpack/NodeEnvironmentPlugin',
  ],
  [
    'webpack/lib/BasicEvaluatedExpression',
    'next/dist/compiled/webpack/BasicEvaluatedExpression',
  ],