@nuxt/webpack-builder 3.6.4 → 3.7.0

package/dist/index.d.mts

@@ -0,0 +1,5 @@
+import { NuxtBuilder } from '@nuxt/schema';
+
+declare const bundle: NuxtBuilder['bundle'];
+
+export { bundle };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { Nuxt } from '@nuxt/schema';
+import { NuxtBuilder } from '@nuxt/schema';
 
-declare function bundle(nuxt: Nuxt): Promise<unknown[] | undefined>;
+declare const bundle: NuxtBuilder['bundle'];
 
 export { bundle };

package/dist/index.mjs

@@ -3,6 +3,7 @@ import webpack from 'webpack';
 import { fromNodeMiddleware, defineEventHandler } from 'h3';
 import webpackDevMiddleware from 'webpack-dev-middleware';
 import webpackHotMiddleware from 'webpack-hot-middleware';
+import { defu } from 'defu';
 import { parseURL, parseQuery, joinURL } from 'ufo';
 import { useNuxt, logger, requireModule } from '@nuxt/kit';
 import { pathToFileURL } from 'node:url';
@@ -40,6 +41,12 @@ function matchWithStringOrRegex(value, matcher) {
   return false;
 }
 
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => {
+  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 const stringTypes = ["Literal", "TemplateLiteral"];
 const NUXT_LIB_RE = /node_modules\/nuxt3?\//;
 const SUPPORTED_EXT_RE = /\.(m?[jt]sx?|vue)/;
@@ -162,8 +169,11 @@ const composableKeysPlugin = createUnplugin((options) => {
 });
 class ScopeTracker {
   constructor() {
+    // the top of the stack is not a part of current key, it is used for next level
+    __publicField$3(this, "scopeIndexStack");
+    __publicField$3(this, "curScopeKey");
     this.scopeIndexStack = [0];
-    this.curScopeKey = "0";
+    this.curScopeKey = "";
   }
   getKey() {
     return this.scopeIndexStack.slice(0, -1).join("-");
@@ -180,8 +190,10 @@ class ScopeTracker {
 }
 class ScopedVarsCollector {
   constructor() {
+    __publicField$3(this, "curScopeKey");
+    __publicField$3(this, "all");
     this.all = /* @__PURE__ */ new Map();
-    this.curScopeKey = "0";
+    this.curScopeKey = "";
   }
   refresh(scopeKey) {
     this.curScopeKey = scopeKey;
@@ -196,7 +208,7 @@ class ScopedVarsCollector {
   }
   hasVar(scopeKey, name) {
     const indices = scopeKey.split("-").map(Number);
-    for (let i = indices.length; i > 0; i--) {
+    for (let i = indices.length; i >= 0; i--) {
       if (this.all.get(indices.slice(0, i).join("-"))?.has(name)) {
         return true;
       }
@@ -335,6 +347,7 @@ function createWebpackConfigContext(nuxt) {
   return {
     nuxt,
     options: nuxt.options,
+    userConfig: nuxt.options.webpack,
     config: {},
     name: "base",
     isDev: nuxt.options.dev,
@@ -357,12 +370,11 @@ function applyPresets(ctx, presets) {
   }
 }
 function fileName(ctx, key) {
-  const { options } = ctx;
-  let fileName2 = options.webpack.filenames[key];
+  let fileName2 = ctx.userConfig.filenames[key];
   if (typeof fileName2 === "function") {
     fileName2 = fileName2(ctx);
   }
-  if (typeof fileName2 === "string" && options.dev) {
+  if (typeof fileName2 === "string" && ctx.options.dev) {
     const hash = /\[(chunkhash|contenthash|hash)(?::(\d+))?]/.exec(fileName2);
     if (hash) {
       logger.warn(`Notice: Please do not use ${hash[1]} in dev mode to prevent memory leak`);
@@ -371,22 +383,6 @@ function fileName(ctx, key) {
   return fileName2;
 }
 function getWebpackConfig(ctx) {
-  const { extend } = ctx.options.build;
-  if (typeof extend === "function") {
-    logger.warn("[nuxt] The `build.extend` and `webpack.build.extend` properties have been deprecated in Nuxt 3 for some time and will be removed in a future minor release. Instead, you can extend webpack config using the `webpack:config` hook.");
-    const extendedConfig = extend.call(
-      {},
-      ctx.config,
-      { loaders: [], ...ctx }
-    ) || ctx.config;
-    const pragma = /@|#/;
-    const { devtool } = extendedConfig;
-    if (typeof devtool === "string" && pragma.test(devtool)) {
-      extendedConfig.devtool = devtool.replace(pragma, "");
-      logger.warn(`devtool has been normalized to ${extendedConfig.devtool} as webpack documented value`);
-    }
-    return extendedConfig;
-  }
   return cloneDeep(ctx.config);
 }
 
@@ -397,7 +393,7 @@ function assets(ctx) {
       use: [{
         loader: "url-loader",
         options: {
-          ...ctx.options.webpack.loaders.imgUrl,
+          ...ctx.userConfig.loaders.imgUrl,
           name: fileName(ctx, "img")
         }
       }]
@@ -407,7 +403,7 @@ function assets(ctx) {
       use: [{
         loader: "url-loader",
         options: {
-          ...ctx.options.webpack.loaders.fontUrl,
+          ...ctx.userConfig.loaders.fontUrl,
           name: fileName(ctx, "font")
         }
       }]
@@ -417,7 +413,7 @@ function assets(ctx) {
       use: [{
         loader: "file-loader",
         options: {
-          ...ctx.options.webpack.loaders.file,
+          ...ctx.userConfig.loaders.file,
           name: fileName(ctx, "video")
         }
       }]
@@ -425,8 +421,15 @@ function assets(ctx) {
   );
 }
 
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => {
+  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 class WarningIgnorePlugin {
   constructor(filter) {
+    __publicField$2(this, "filter");
     this.filter = filter;
   }
   apply(compiler) {
@@ -446,19 +449,18 @@ function base(ctx) {
   ]);
 }
 function baseConfig(ctx) {
-  const { options } = ctx;
   ctx.config = {
     name: ctx.name,
-    entry: { app: [resolve(options.appDir, options.experimental.asyncEntry ? "entry.async" : "entry")] },
+    entry: { app: [resolve(ctx.options.appDir, ctx.options.experimental.asyncEntry ? "entry.async" : "entry")] },
     module: { rules: [] },
     plugins: [],
     externals: [],
     optimization: {
-      ...options.webpack.optimization,
+      ...ctx.userConfig.optimization,
       minimizer: []
     },
     experiments: {
-      ...options.webpack.experiments
+      ...ctx.userConfig.experiments
     },
     mode: ctx.isDev ? "development" : "production",
     cache: getCache(ctx),
@@ -468,16 +470,15 @@ function baseConfig(ctx) {
   };
 }
 function basePlugins(ctx) {
-  const { config, options, nuxt } = ctx;
-  config.plugins = config.plugins || [];
-  if (options.dev) {
-    config.plugins.push(new TimeFixPlugin());
+  ctx.config.plugins = ctx.config.plugins || [];
+  if (ctx.options.dev) {
+    ctx.config.plugins.push(new TimeFixPlugin());
   }
-  config.plugins.push(...options.webpack.plugins || []);
-  config.plugins.push(new WarningIgnorePlugin(getWarningIgnoreFilter(ctx)));
-  config.plugins.push(new webpack.DefinePlugin(getEnv(ctx)));
-  if (ctx.isServer || ctx.isDev && options.webpack.friendlyErrors) {
-    config.plugins.push(
+  ctx.config.plugins.push(...ctx.userConfig.plugins || []);
+  ctx.config.plugins.push(new WarningIgnorePlugin(getWarningIgnoreFilter(ctx)));
+  ctx.config.plugins.push(new webpack.DefinePlugin(getEnv(ctx)));
+  if (ctx.isServer || ctx.isDev && ctx.userConfig.friendlyErrors) {
+    ctx.config.plugins.push(
       new FriendlyErrorsWebpackPlugin({
         clearConsole: false,
         reporter: "consola",
@@ -486,13 +487,13 @@ function basePlugins(ctx) {
       })
     );
   }
-  if (nuxt.options.webpack.profile) {
+  if (ctx.nuxt.options.webpack.profile) {
     const colors = {
       client: "green",
       server: "orange",
       modern: "blue"
     };
-    config.plugins.push(new WebpackBar({
+    ctx.config.plugins.push(new WebpackBar({
       name: ctx.name,
       color: colors[ctx.name],
       reporters: ["stats"],
@@ -502,21 +503,21 @@ function basePlugins(ctx) {
         reporter: {
           change: (_, { shortPath }) => {
             if (!ctx.isServer) {
-              nuxt.callHook("webpack:change", shortPath);
+              ctx.nuxt.callHook("webpack:change", shortPath);
             }
           },
           done: ({ state }) => {
             if (state.hasErrors) {
-              nuxt.callHook("webpack:error");
+              ctx.nuxt.callHook("webpack:error");
             } else {
               logger.success(`${state.name} ${state.message}`);
             }
           },
           allDone: () => {
-            nuxt.callHook("webpack:done");
+            ctx.nuxt.callHook("webpack:done");
           },
           progress({ statesArray }) {
-            nuxt.callHook("webpack:progress", statesArray);
+            ctx.nuxt.callHook("webpack:progress", statesArray);
           }
         }
       }
@@ -524,12 +525,11 @@ function basePlugins(ctx) {
   }
 }
 function baseAlias(ctx) {
-  const { options } = ctx;
   ctx.alias = {
-    "#app": options.appDir,
-    "#build/plugins": resolve(options.buildDir, "plugins", ctx.isClient ? "client" : "server"),
-    "#build": options.buildDir,
-    ...options.alias,
+    "#app": ctx.options.appDir,
+    "#build/plugins": resolve(ctx.options.buildDir, "plugins", ctx.isClient ? "client" : "server"),
+    "#build": ctx.options.buildDir,
+    ...ctx.options.alias,
     ...ctx.alias
   };
   if (ctx.isClient) {
@@ -537,22 +537,20 @@ function baseAlias(ctx) {
   }
 }
 function baseResolve(ctx) {
-  const { options, config } = ctx;
-  const webpackModulesDir = ["node_modules"].concat(options.modulesDir);
-  config.resolve = {
+  const webpackModulesDir = ["node_modules"].concat(ctx.options.modulesDir);
+  ctx.config.resolve = {
     extensions: [".wasm", ".mjs", ".js", ".ts", ".json", ".vue", ".jsx", ".tsx"],
     alias: ctx.alias,
     modules: webpackModulesDir,
     fullySpecified: false,
-    ...config.resolve
+    ...ctx.config.resolve
   };
-  config.resolveLoader = {
+  ctx.config.resolveLoader = {
     modules: webpackModulesDir,
-    ...config.resolveLoader
+    ...ctx.config.resolveLoader
   };
 }
 function baseTranspile(ctx) {
-  const { options } = ctx;
   const transpile = [
     /\.vue\.js/i,
     // include SFCs in node_modules
@@ -560,7 +558,7 @@ function baseTranspile(ctx) {
     /vue-demi/,
     /(^|\/)nuxt\/(dist\/)?(app|[^/]+\/runtime)($|\/)/
   ];
-  for (let pattern of options.build.transpile) {
+  for (let pattern of ctx.options.build.transpile) {
     if (typeof pattern === "function") {
       const result = pattern(ctx);
       if (result) {
@@ -576,43 +574,44 @@ function baseTranspile(ctx) {
   ctx.transpile = [...transpile, ...ctx.transpile];
 }
 function getCache(ctx) {
-  const { options } = ctx;
-  if (!options.dev) {
+  if (!ctx.options.dev) {
     return false;
   }
 }
 function getOutput(ctx) {
-  const { options } = ctx;
   return {
-    path: resolve(options.buildDir, "dist", ctx.isServer ? "server" : joinURL("client", options.app.buildAssetsDir)),
+    path: resolve(ctx.options.buildDir, "dist", ctx.isServer ? "server" : joinURL("client", ctx.options.app.buildAssetsDir)),
     filename: fileName(ctx, "app"),
     chunkFilename: fileName(ctx, "chunk"),
-    publicPath: joinURL(options.app.baseURL, options.app.buildAssetsDir)
+    publicPath: joinURL(ctx.options.app.baseURL, ctx.options.app.buildAssetsDir)
   };
 }
 function getWarningIgnoreFilter(ctx) {
-  const { options } = ctx;
   const filters = [
     // Hide warnings about plugins without a default export (#1179)
     (warn) => warn.name === "ModuleDependencyWarning" && warn.message.includes("export 'default'") && warn.message.includes("nuxt_plugin_"),
-    ...options.webpack.warningIgnoreFilters || []
+    ...ctx.userConfig.warningIgnoreFilters || []
   ];
   return (warn) => !filters.some((ignoreFilter) => ignoreFilter(warn));
 }
 function getEnv(ctx) {
-  const { options } = ctx;
   const _env = {
     "process.env.NODE_ENV": JSON.stringify(ctx.config.mode),
-    "process.mode": JSON.stringify(ctx.config.mode),
-    "process.dev": options.dev,
-    "process.test": isTest,
     __NUXT_VERSION__: JSON.stringify(ctx.nuxt._version),
     "process.env.VUE_ENV": JSON.stringify(ctx.name),
+    "process.env.NUXT_ASYNC_CONTEXT": ctx.options.experimental.asyncContext,
+    "process.dev": ctx.options.dev,
+    "process.test": isTest,
     "process.browser": ctx.isClient,
     "process.client": ctx.isClient,
-    "process.server": ctx.isServer
+    "process.server": ctx.isServer,
+    "import.meta.dev": ctx.options.dev,
+    "import.meta.test": isTest,
+    "import.meta.browser": ctx.isClient,
+    "import.meta.client": ctx.isClient,
+    "import.meta.server": ctx.isServer
   };
-  if (options.webpack.aggressiveCodeRemoval) {
+  if (ctx.userConfig.aggressiveCodeRemoval) {
     _env["typeof process"] = JSON.stringify(ctx.isServer ? "object" : "undefined");
     _env["typeof window"] = _env["typeof document"] = JSON.stringify(!ctx.isServer ? "object" : "undefined");
   }
@@ -625,10 +624,9 @@ const statsMap = {
 };
 
 function esbuild(ctx) {
-  const { config } = ctx;
-  const target = ctx.isServer ? "es2019" : "chrome85";
-  config.optimization.minimizer.push(new EsbuildPlugin());
-  config.module.rules.push(
+  const target = ctx.isServer ? "es2020" : "chrome85";
+  ctx.config.optimization.minimizer.push(new EsbuildPlugin());
+  ctx.config.module.rules.push(
     {
       test: /\.m?[jt]s$/i,
       loader: "esbuild-loader",
@@ -668,7 +666,7 @@ function pug(ctx) {
         resourceQuery: /^\?vue/i,
         use: [{
           loader: "pug-plain-loader",
-          options: ctx.options.webpack.loaders.pugPlain
+          options: ctx.userConfig.loaders.pugPlain
         }]
       },
       {
@@ -676,7 +674,7 @@ function pug(ctx) {
           "raw-loader",
           {
             loader: "pug-plain-loader",
-            options: ctx.options.webpack.loaders.pugPlain
+            options: ctx.userConfig.loaders.pugPlain
           }
         ]
       }
@@ -761,45 +759,41 @@ function style(ctx) {
   ]);
 }
 function minimizer(ctx) {
-  const { options, config } = ctx;
-  if (options.webpack.optimizeCSS && Array.isArray(config.optimization.minimizer)) {
-    config.optimization.minimizer.push(new CssMinimizerPlugin({
-      ...options.webpack.optimizeCSS
+  if (ctx.userConfig.optimizeCSS && Array.isArray(ctx.config.optimization.minimizer)) {
+    ctx.config.optimization.minimizer.push(new CssMinimizerPlugin({
+      ...ctx.userConfig.optimizeCSS
     }));
   }
 }
 function extractCSS(ctx) {
-  const { options, config } = ctx;
-  if (options.webpack.extractCSS) {
-    config.plugins.push(new MiniCssExtractPlugin({
+  if (ctx.userConfig.extractCSS) {
+    ctx.config.plugins.push(new MiniCssExtractPlugin({
       filename: fileName(ctx, "css"),
       chunkFilename: fileName(ctx, "css"),
-      ...options.webpack.extractCSS === true ? {} : options.webpack.extractCSS
+      ...ctx.userConfig.extractCSS === true ? {} : ctx.userConfig.extractCSS
     }));
   }
 }
 function loaders(ctx) {
-  const { config, options } = ctx;
-  config.module.rules.push(createdStyleRule("css", /\.css$/i, null, ctx));
-  config.module.rules.push(createdStyleRule("postcss", /\.p(ost)?css$/i, null, ctx));
-  const lessLoader = { loader: "less-loader", options: options.webpack.loaders.less };
-  config.module.rules.push(createdStyleRule("less", /\.less$/i, lessLoader, ctx));
-  const sassLoader = { loader: "sass-loader", options: options.webpack.loaders.sass };
-  config.module.rules.push(createdStyleRule("sass", /\.sass$/i, sassLoader, ctx));
-  const scssLoader = { loader: "sass-loader", options: options.webpack.loaders.scss };
-  config.module.rules.push(createdStyleRule("scss", /\.scss$/i, scssLoader, ctx));
-  const stylusLoader = { loader: "stylus-loader", options: options.webpack.loaders.stylus };
-  config.module.rules.push(createdStyleRule("stylus", /\.styl(us)?$/i, stylusLoader, ctx));
+  ctx.config.module.rules.push(createdStyleRule("css", /\.css$/i, null, ctx));
+  ctx.config.module.rules.push(createdStyleRule("postcss", /\.p(ost)?css$/i, null, ctx));
+  const lessLoader = { loader: "less-loader", options: ctx.userConfig.loaders.less };
+  ctx.config.module.rules.push(createdStyleRule("less", /\.less$/i, lessLoader, ctx));
+  const sassLoader = { loader: "sass-loader", options: ctx.userConfig.loaders.sass };
+  ctx.config.module.rules.push(createdStyleRule("sass", /\.sass$/i, sassLoader, ctx));
+  const scssLoader = { loader: "sass-loader", options: ctx.userConfig.loaders.scss };
+  ctx.config.module.rules.push(createdStyleRule("scss", /\.scss$/i, scssLoader, ctx));
+  const stylusLoader = { loader: "stylus-loader", options: ctx.userConfig.loaders.stylus };
+  ctx.config.module.rules.push(createdStyleRule("stylus", /\.styl(us)?$/i, stylusLoader, ctx));
 }
 function createdStyleRule(lang, test, processorLoader, ctx) {
-  const { options } = ctx;
   const styleLoaders = [
     createPostcssLoadersRule(ctx),
     processorLoader
   ].filter(Boolean);
-  options.webpack.loaders.css.importLoaders = options.webpack.loaders.cssModules.importLoaders = styleLoaders.length;
-  const cssLoaders = createCssLoadersRule(ctx, options.webpack.loaders.css);
-  const cssModuleLoaders = createCssLoadersRule(ctx, options.webpack.loaders.cssModules);
+  ctx.userConfig.loaders.css.importLoaders = ctx.userConfig.loaders.cssModules.importLoaders = styleLoaders.length;
+  const cssLoaders = createCssLoadersRule(ctx, ctx.userConfig.loaders.css);
+  const cssModuleLoaders = createCssLoadersRule(ctx, ctx.userConfig.loaders.cssModules);
   return {
     test,
     oneOf: [
@@ -816,9 +810,8 @@ function createdStyleRule(lang, test, processorLoader, ctx) {
   };
 }
 function createCssLoadersRule(ctx, cssLoaderOptions) {
-  const { options } = ctx;
   const cssLoader = { loader: "css-loader", options: cssLoaderOptions };
-  if (options.webpack.extractCSS) {
+  if (ctx.userConfig.extractCSS) {
     if (ctx.isServer) {
       if (cssLoader.options.modules) {
         cssLoader.options.modules.exportOnlyLocals = cssLoader.options.modules.exportOnlyLocals ?? true;
@@ -842,11 +835,10 @@ function createCssLoadersRule(ctx, cssLoaderOptions) {
   ];
 }
 function createPostcssLoadersRule(ctx) {
-  const { options, nuxt } = ctx;
-  if (!options.postcss) {
+  if (!ctx.options.postcss) {
     return;
   }
-  const config = getPostcssConfig(nuxt);
+  const config = getPostcssConfig(ctx.nuxt);
   if (!config) {
     return;
   }
@@ -872,8 +864,15 @@ const extractQueryPartJS = (file) => isJSRegExp.exec(file)?.[1];
 const isCSS = (file) => /\.css(\?[^.]+)?$/.test(file);
 const isHotUpdate = (file) => file.includes("hot-update");
 
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 class VueSSRClientPlugin {
   constructor(options) {
+    __publicField$1(this, "options");
     this.options = Object.assign({
       filename: null
     }, options);
@@ -952,9 +951,16 @@ class VueSSRClientPlugin {
   }
 }
 
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 const JS_MAP_RE = /\.js\.map$/;
 class VueSSRServerPlugin {
   constructor(options = {}) {
+    __publicField(this, "options");
     this.options = Object.assign({
       filename: null
     }, options);
@@ -1021,27 +1027,26 @@ class VueSSRServerPlugin {
 }
 
 function vue(ctx) {
-  const { options, config } = ctx;
-  config.plugins.push(new (VueLoaderPlugin.default || VueLoaderPlugin)());
-  config.module.rules.push({
+  ctx.config.plugins.push(new (VueLoaderPlugin.default || VueLoaderPlugin)());
+  ctx.config.module.rules.push({
     test: /\.vue$/i,
     loader: "vue-loader",
     options: {
       reactivityTransform: ctx.nuxt.options.experimental.reactivityTransform,
-      ...options.webpack.loaders.vue
+      ...ctx.userConfig.loaders.vue
     }
   });
   if (ctx.isClient) {
-    config.plugins.push(new VueSSRClientPlugin({
-      filename: resolve(options.buildDir, "dist/server", `${ctx.name}.manifest.json`),
+    ctx.config.plugins.push(new VueSSRClientPlugin({
+      filename: resolve(ctx.options.buildDir, "dist/server", `${ctx.name}.manifest.json`),
       nuxt: ctx.nuxt
     }));
   } else {
-    config.plugins.push(new VueSSRServerPlugin({
+    ctx.config.plugins.push(new VueSSRServerPlugin({
       filename: `${ctx.name}.manifest.json`
     }));
   }
-  config.plugins.push(new webpack.DefinePlugin({
+  ctx.config.plugins.push(new webpack.DefinePlugin({
     __VUE_OPTIONS_API__: "true",
     __VUE_PROD_DEVTOOLS__: "false"
   }));
@@ -1075,11 +1080,12 @@ function clientDevtool(ctx) {
     ctx.config.devtool = false;
     return;
   }
+  const prefix = ctx.nuxt.options.sourcemap.client === "hidden" ? "hidden-" : "";
   if (!ctx.isDev) {
-    ctx.config.devtool = "source-map";
+    ctx.config.devtool = prefix + "source-map";
     return;
   }
-  ctx.config.devtool = "eval-cheap-module-source-map";
+  ctx.config.devtool = prefix + "eval-cheap-module-source-map";
 }
 function clientPerformance(ctx) {
   ctx.config.performance = {
@@ -1089,48 +1095,46 @@ function clientPerformance(ctx) {
   };
 }
 function clientHMR(ctx) {
-  const { options, config } = ctx;
   if (!ctx.isDev) {
     return;
   }
-  const clientOptions = options.webpack.hotMiddleware?.client || {};
+  const clientOptions = ctx.userConfig.hotMiddleware?.client || {};
   const hotMiddlewareClientOptions = {
     reload: true,
     timeout: 3e4,
-    path: joinURL(options.app.baseURL, "__webpack_hmr", ctx.name),
+    path: joinURL(ctx.options.app.baseURL, "__webpack_hmr", ctx.name),
     ...clientOptions,
     ansiColors: JSON.stringify(clientOptions.ansiColors || {}),
     overlayStyles: JSON.stringify(clientOptions.overlayStyles || {}),
     name: ctx.name
   };
   const hotMiddlewareClientOptionsStr = querystring.stringify(hotMiddlewareClientOptions);
-  const app = config.entry.app;
+  const app = ctx.config.entry.app;
   app.unshift(
     // https://github.com/glenjamin/webpack-hot-middleware#config
     `webpack-hot-middleware/client?${hotMiddlewareClientOptionsStr}`
   );
-  config.plugins = config.plugins || [];
-  config.plugins.push(new webpack.HotModuleReplacementPlugin());
+  ctx.config.plugins = ctx.config.plugins || [];
+  ctx.config.plugins.push(new webpack.HotModuleReplacementPlugin());
 }
 function clientOptimization(_ctx) {
 }
 function clientPlugins(ctx) {
-  const { options, config } = ctx;
-  if (!ctx.isDev && ctx.name === "client" && options.webpack.analyze) {
-    const statsDir = resolve(options.analyzeDir);
-    config.plugins.push(new BundleAnalyzerPlugin({
+  if (!ctx.isDev && ctx.name === "client" && ctx.userConfig.analyze) {
+    const statsDir = resolve(ctx.options.analyzeDir);
+    ctx.config.plugins.push(new BundleAnalyzerPlugin({
       analyzerMode: "static",
       defaultSizes: "gzip",
       generateStatsFile: true,
       openAnalyzer: true,
       reportFilename: resolve(statsDir, `${ctx.name}.html`),
       statsFilename: resolve(statsDir, `${ctx.name}.json`),
-      ...options.webpack.analyze === true ? {} : options.webpack.analyze
+      ...ctx.userConfig.analyze === true ? {} : ctx.userConfig.analyze
     }));
   }
   if (!ctx.nuxt.options.ssr) {
     if (ctx.nuxt.options.typescript.typeCheck === true || ctx.nuxt.options.typescript.typeCheck === "build" && !ctx.nuxt.options.dev) {
-      config.plugins.push(new ForkTSCheckerWebpackPlugin({
+      ctx.config.plugins.push(new ForkTSCheckerWebpackPlugin({
         logger
       }));
     }
@@ -1138,12 +1142,11 @@ function clientPlugins(ctx) {
 }
 
 function node(ctx) {
-  const { config } = ctx;
-  config.target = "node";
-  config.node = false;
-  config.experiments.outputModule = true;
-  config.output = {
-    ...config.output,
+  ctx.config.target = "node";
+  ctx.config.node = false;
+  ctx.config.experiments.outputModule = true;
+  ctx.config.output = {
+    ...ctx.config.output,
     chunkFilename: "[name].mjs",
     chunkFormat: "module",
     chunkLoading: "import",
@@ -1161,8 +1164,8 @@ function node(ctx) {
       type: "module"
     }
   };
-  config.performance = {
-    ...config.performance,
+  ctx.config.performance = {
+    ...ctx.config.performance,
     hints: false,
     maxEntrypointSize: Infinity,
     maxAssetSize: Infinity
@@ -1183,10 +1186,14 @@ function server(ctx) {
   return getWebpackConfig(ctx);
 }
 function serverPreset(ctx) {
-  const { config } = ctx;
-  config.output.filename = "server.mjs";
-  config.devtool = ctx.nuxt.options.sourcemap.server ? ctx.isDev ? "cheap-module-source-map" : "source-map" : false;
-  config.optimization = {
+  ctx.config.output.filename = "server.mjs";
+  if (ctx.nuxt.options.sourcemap.server) {
+    const prefix = ctx.nuxt.options.sourcemap.server === "hidden" ? "hidden-" : "";
+    ctx.config.devtool = prefix + ctx.isDev ? "cheap-module-source-map" : "source-map";
+  } else {
+    ctx.config.devtool = false;
+  }
+  ctx.config.optimization = {
     splitChunks: false,
     minimize: false
   };
@@ -1222,25 +1229,25 @@ function serverStandalone(ctx) {
   });
 }
 function serverPlugins(ctx) {
-  const { config, options } = ctx;
-  config.plugins = config.plugins || [];
-  if (options.webpack.serverURLPolyfill) {
-    config.plugins.push(new webpack.ProvidePlugin({
-      URL: [options.webpack.serverURLPolyfill, "URL"],
-      URLSearchParams: [options.webpack.serverURLPolyfill, "URLSearchParams"]
+  ctx.config.plugins = ctx.config.plugins || [];
+  if (ctx.userConfig.serverURLPolyfill) {
+    ctx.config.plugins.push(new webpack.ProvidePlugin({
+      URL: [ctx.userConfig.serverURLPolyfill, "URL"],
+      URLSearchParams: [ctx.userConfig.serverURLPolyfill, "URLSearchParams"]
     }));
   }
   if (ctx.nuxt.options.typescript.typeCheck === true || ctx.nuxt.options.typescript.typeCheck === "build" && !ctx.nuxt.options.dev) {
-    config.plugins.push(new ForkTSCheckerWebpackPlugin({
+    ctx.config.plugins.push(new ForkTSCheckerWebpackPlugin({
       logger
     }));
   }
 }
 
-async function bundle(nuxt) {
+const bundle = async (nuxt) => {
   registerVirtualModules();
   const webpackConfigs = [client, ...nuxt.options.ssr ? [server] : []].map((preset) => {
     const ctx = createWebpackConfigContext(nuxt);
+    ctx.userConfig = defu(nuxt.options.webpack[`$${preset.name}`], ctx.userConfig);
     applyPresets(ctx, preset);
     return getWebpackConfig(ctx);
   });
@@ -1248,13 +1255,13 @@ async function bundle(nuxt) {
   const mfs = nuxt.options.dev ? createMFS() : null;
   for (const config of webpackConfigs) {
     config.plugins.push(DynamicBasePlugin.webpack({
-      sourcemap: nuxt.options.sourcemap[config.name]
+      sourcemap: !!nuxt.options.sourcemap[config.name]
     }));
     if (config.name === "client" && nuxt.options.experimental.emitRouteChunkError) {
       config.plugins.push(new ChunkErrorPlugin());
     }
     config.plugins.push(composableKeysPlugin.webpack({
-      sourcemap: nuxt.options.sourcemap[config.name],
+      sourcemap: !!nuxt.options.sourcemap[config.name],
       rootDir: nuxt.options.rootDir,
       composables: nuxt.options.optimization.keyedComposables
     }));
@@ -1273,12 +1280,13 @@ async function bundle(nuxt) {
     }
   });
   if (nuxt.options.dev) {
-    return Promise.all(compilers.map((c) => compile(c)));
+    await Promise.all(compilers.map((c) => compile(c)));
+    return;
   }
   for (const c of compilers) {
     await compile(c);
   }
-}
+};
 async function createDevMiddleware(compiler) {
   const nuxt = useNuxt();
   logger.debug("Creating webpack middleware...");
@@ -1306,17 +1314,16 @@ async function createDevMiddleware(compiler) {
 }
 async function compile(compiler) {
   const nuxt = useNuxt();
-  const { name } = compiler.options;
-  await nuxt.callHook("webpack:compile", { name, compiler });
+  await nuxt.callHook("webpack:compile", { name: compiler.options.name, compiler });
   compiler.hooks.done.tap("load-resources", async (stats2) => {
-    await nuxt.callHook("webpack:compiled", { name, compiler, stats: stats2 });
+    await nuxt.callHook("webpack:compiled", { name: compiler.options.name, compiler, stats: stats2 });
   });
   if (nuxt.options.dev) {
     const compilersWatching = [];
     nuxt.hook("close", async () => {
       await Promise.all(compilersWatching.map((watching) => pify(watching.close.bind(watching))()));
     });
-    if (name === "client") {
+    if (compiler.options.name === "client") {
       return new Promise((resolve, reject) => {
         compiler.hooks.done.tap("nuxt-dev", () => {
           resolve(null);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/webpack-builder",
-  "version": "3.6.4",
+  "version": "3.7.0",
   "repository": "nuxt/nuxt",
   "license": "MIT",
   "type": "module",
@@ -17,57 +17,58 @@
   ],
   "dependencies": {
     "@nuxt/friendly-errors-webpack-plugin": "^2.5.2",
-    "autoprefixer": "^10.4.14",
+    "autoprefixer": "^10.4.15",
     "css-loader": "^6.8.1",
     "css-minimizer-webpack-plugin": "^5.0.1",
     "cssnano": "^6.0.1",
-    "esbuild-loader": "^3.0.1",
+    "defu": "^6.1.2",
+    "esbuild-loader": "^4.0.1",
     "escape-string-regexp": "^5.0.0",
     "estree-walker": "^3.0.3",
     "file-loader": "^6.2.0",
     "fork-ts-checker-webpack-plugin": "^8.0.0",
     "fs-extra": "^11.1.1",
-    "h3": "^1.7.1",
+    "h3": "^1.8.0",
     "hash-sum": "^2.0.0",
     "lodash-es": "^4.17.21",
-    "magic-string": "^0.30.1",
-    "memfs": "^4.2.0",
+    "magic-string": "^0.30.3",
+    "memfs": "^4.2.1",
     "mini-css-extract-plugin": "^2.7.6",
-    "mlly": "^1.4.0",
-    "ohash": "^1.1.2",
+    "mlly": "^1.4.1",
+    "ohash": "^1.1.3",
     "pathe": "^1.1.1",
     "pify": "^6.1.0",
-    "postcss": "^8.4.24",
+    "postcss": "^8.4.28",
     "postcss-import": "^15.1.0",
     "postcss-loader": "^7.3.3",
     "postcss-url": "^10.1.3",
     "pug-plain-loader": "^1.1.0",
-    "std-env": "^3.3.3",
+    "std-env": "^3.4.3",
     "time-fix-plugin": "^2.0.7",
-    "ufo": "^1.1.2",
-    "unplugin": "^1.3.2",
+    "ufo": "^1.3.0",
+    "unplugin": "^1.4.0",
     "url-loader": "^4.1.1",
-    "vue-bundle-renderer": "^1.0.3",
+    "vue-bundle-renderer": "^2.0.0",
     "vue-loader": "^17.2.2",
-    "webpack": "^5.88.1",
+    "webpack": "^5.88.2",
     "webpack-bundle-analyzer": "^4.9.0",
     "webpack-dev-middleware": "^6.1.1",
     "webpack-hot-middleware": "^2.25.4",
     "webpack-virtual-modules": "^0.5.0",
     "webpackbar": "^5.0.2",
-    "@nuxt/kit": "3.6.4"
+    "@nuxt/kit": "3.7.0"
   },
   "devDependencies": {
     "@types/fs-extra": "11.0.1",
     "@types/hash-sum": "1.0.0",
-    "@types/lodash-es": "4.17.7",
+    "@types/lodash-es": "4.17.8",
     "@types/pify": "5.0.1",
     "@types/webpack-bundle-analyzer": "4.6.0",
     "@types/webpack-hot-middleware": "2.25.6",
     "@types/webpack-virtual-modules": "0.1.1",
     "unbuild": "latest",
     "vue": "3.3.4",
-    "@nuxt/schema": "3.6.4"
+    "@nuxt/schema": "3.7.0"
   },
   "peerDependencies": {
     "vue": "^3.3.4"