vike 0.4.226 → 0.4.227-commit-c9cc081

package/dist/cjs/node/prerender/runPrerender.js

@@ -69,6 +69,7 @@ const getOutDirs_js_1 = require("../plugin/shared/getOutDirs.js");
 const context_js_2 = require("../cli/context.js");
 const isViteCliCall_js_1 = require("../plugin/shared/isViteCliCall.js");
 const commonConfig_js_1 = require("../plugin/plugins/commonConfig.js");
+const node_fs_1 = __importDefault(require("node:fs"));
 async function runPrerenderFromAPI(options = {}) {
     return await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
@@ -88,11 +89,9 @@ async function runPrerenderFromCLIPrerenderCommand() {
     runPrerender_forceExit();
     (0, utils_js_1.assert)(false);
 }
-async function runPrerenderFromAutoRun(viteConfig, config) {
-    let prerenderContextPublic;
+async function runPrerenderFromAutoRun(viteConfig) {
     try {
-        const ret = await runPrerender({ viteConfig });
-        prerenderContextPublic = ret.prerenderContextPublic;
+        await runPrerender({ viteConfig });
     }
     catch (err) {
         // Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
@@ -100,8 +99,6 @@ async function runPrerenderFromAutoRun(viteConfig, config) {
         (0, logErrorHint_js_1.logErrorHint)(err);
         process.exit(1);
     }
-    const vike = (0, commonConfig_js_1.getVikeConfigPublic)(config);
-    vike.prerenderContext = prerenderContextPublic;
     const forceExit = (0, context_js_2.isVikeCli)() || (0, isViteCliCall_js_1.isViteCliCall)();
     return { forceExit };
 }
@@ -118,7 +115,9 @@ async function runPrerender(options = {}, standaloneTrigger) {
     await disableReactStreaming();
     const viteConfig = await (0, vite_1.resolveConfig)(options.viteConfig || {}, 'build', 'production');
     const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(viteConfig);
-    const { outDirClient } = (0, getOutDirs_js_1.getOutDirs)(viteConfig);
+    const vike = (0, commonConfig_js_1.getVikeConfigPublic)(viteConfig);
+    (0, utils_js_1.assert)(vike.prerenderContext.isPrerenderingEnabled);
+    const { outDirClient, outDirServer } = (0, getOutDirs_js_1.getOutDirs)(viteConfig);
     const { root } = viteConfig;
     const prerenderConfigGlobal = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig);
     validatePrerenderConfig(prerenderConfigGlobal);
@@ -161,7 +160,11 @@ async function runPrerender(options = {}, standaloneTrigger) {
     }
     await warnMissingPages(prerenderContext.prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
     const prerenderContextPublic = makePublic(prerenderContext);
-    return { viteConfig, prerenderContextPublic };
+    (0, utils_js_1.objectAssign)(vike.prerenderContext, prerenderContextPublic);
+    if (prerenderConfigGlobal.isPrerenderingEnabledForAllPages && !prerenderConfigGlobal.keepDistServer) {
+        node_fs_1.default.rmSync(outDirServer, { recursive: true });
+    }
+    return { viteConfig };
 }
 async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext) {
     // V1 design
@@ -630,6 +633,12 @@ async function write(urlOriginal, pageContext, fileType, fileContent, root, outD
     (0, utils_js_1.assertPosixPath)(outDirClient);
     (0, utils_js_1.assertPosixPath)(filePathRelative);
     const filePath = path_1.default.posix.join(outDirClient, filePathRelative);
+    (0, utils_js_1.objectAssign)(pageContext, {
+        _prerenderResult: {
+            filePath,
+            fileContent
+        }
+    });
     output.push({
         filePath,
         fileType,
@@ -637,15 +646,7 @@ async function write(urlOriginal, pageContext, fileType, fileContent, root, outD
         pageContext
     });
     if (onPagePrerender) {
-        const prerenderPageContext = {};
-        (0, utils_js_1.objectAssign)(prerenderPageContext, pageContext);
-        (0, utils_js_1.objectAssign)(prerenderPageContext, {
-            _prerenderResult: {
-                filePath,
-                fileContent
-            }
-        });
-        await onPagePrerender(prerenderPageContext);
+        await onPagePrerender(pageContext);
     }
     else {
         const { promises } = await Promise.resolve().then(() => __importStar(require('fs')));

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.226';
+exports.PROJECT_VERSION = '0.4.227-commit-c9cc081';

package/dist/cjs/utils/assert.js

@@ -98,12 +98,9 @@ function assertWarning(condition, msg, { onlyOnce, showStackTrace }) {
     if (onlyOnce) {
         const { alreadyLogged } = globalObject;
         const key = onlyOnce === true ? msg : onlyOnce;
-        if (alreadyLogged.has(key)) {
+        if (alreadyLogged.has(key))
             return;
-        }
-        else {
-            alreadyLogged.add(key);
-        }
+        alreadyLogged.add(key);
     }
     globalObject.onBeforeLog?.();
     if (showStackTrace) {

package/dist/cjs/utils/assertSingleInstance.js

@@ -16,13 +16,24 @@ const PROJECT_VERSION_js_1 = require("./PROJECT_VERSION.js");
 /* Use original assertWarning() after all CJS is removed from node_modules/vike/dist/
 import { assertWarning } from './assert.js'
 */
-const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('utils/assertSingleInstance.ts', {
-    instances: [],
-    alreadyLogged: new Set()
-});
+let globalObject;
+// getGlobalObjectSafe() can be called before this line
+globalObject ?? (globalObject = genGlobalConfig());
+function genGlobalConfig() {
+    return (0, getGlobalObject_js_1.getGlobalObject)('utils/assertSingleInstance.ts', {
+        instances: [],
+        alreadyLogged: new Set()
+    });
+}
+// We need getGlobalObjectSafe() because globalObject is `undefined` when exported functions are called before globalObject is initialized
+function getGlobalObjectSafe() {
+    globalObject ?? (globalObject = genGlobalConfig());
+    return globalObject;
+}
 const clientRuntimesClonflict = 'Client runtime of both Server Routing and Client Routing loaded https://vike.dev/client-runtimes-conflict';
 const clientNotSingleInstance = 'Client runtime loaded twice https://vike.dev/client-runtime-duplicated';
 function assertSingleInstance() {
+    const globalObject = getGlobalObjectSafe();
     {
         const versions = (0, unique_js_1.unique)(globalObject.instances);
         assertWarning(versions.length <= 1, 
@@ -39,6 +50,7 @@ function assertSingleInstance() {
     }
 }
 function assertSingleInstance_onClientEntryServerRouting(isProduction) {
+    const globalObject = getGlobalObjectSafe();
     assertWarning(globalObject.isClientRouting !== true, clientRuntimesClonflict, {
         onlyOnce: true,
         showStackTrace: true
@@ -53,6 +65,7 @@ function assertSingleInstance_onClientEntryServerRouting(isProduction) {
     assertSingleInstance();
 }
 function assertSingleInstance_onClientEntryClientRouting(isProduction) {
+    const globalObject = getGlobalObjectSafe();
     assertWarning(globalObject.isClientRouting !== false, clientRuntimesClonflict, {
         onlyOnce: true,
         showStackTrace: true
@@ -68,10 +81,12 @@ function assertSingleInstance_onClientEntryClientRouting(isProduction) {
 }
 // Called by utils/assert.ts which is (most certainly) loaded by all entries. That way we don't have to call a callback for every entry. (There are a lot of entries: `client/router/`, `client/`, `node/runtime/`, `node/plugin/`, `node/cli`.)
 function assertSingleInstance_onAssertModuleLoad() {
+    const globalObject = getGlobalObjectSafe();
     globalObject.instances.push(PROJECT_VERSION_js_1.PROJECT_VERSION);
     assertSingleInstance();
 }
 function assertWarning(condition, errorMessage, { onlyOnce, showStackTrace }) {
+    const globalObject = getGlobalObjectSafe();
     if (condition) {
         return;
     }

package/dist/esm/node/cli/entry.js

@@ -24,14 +24,19 @@ async function cmdDev() {
     const startTime = performance.now();
     try {
         const { viteServer } = await dev();
-        await viteServer.listen();
-        const info = viteServer.config.logger.info;
-        const startupDurationString = pc.dim(`ready in ${pc.reset(pc.bold(String(Math.ceil(performance.now() - startTime))))} ms`);
-        const hasExistingLogs = process.stdout.bytesWritten > 0 || process.stderr.bytesWritten > 0;
-        info(`  ${pc.yellow(`${pc.bold('Vike')} v${PROJECT_VERSION}`)}  ${startupDurationString}\n`, {
-            clear: !hasExistingLogs
-        });
-        viteServer.printUrls();
+        if (viteServer.httpServer) {
+            await viteServer.listen();
+            const info = viteServer.config.logger.info;
+            const startupDurationString = pc.dim(`ready in ${pc.reset(pc.bold(String(Math.ceil(performance.now() - startTime))))} ms`);
+            const hasExistingLogs = process.stdout.bytesWritten > 0 || process.stderr.bytesWritten > 0;
+            info(`  ${pc.yellow(`${pc.bold('Vike')} v${PROJECT_VERSION}`)}  ${startupDurationString}\n`, {
+                clear: !hasExistingLogs
+            });
+            viteServer.printUrls();
+        }
+        else {
+            // vike-server => middleware mode => `viteServer.httpServer === null`
+        }
         viteServer.bindCLIShortcuts({ print: true });
     }
     catch (err) {

package/dist/esm/node/plugin/plugins/build/pluginAutoFullBuild.js

@@ -1,3 +1,4 @@
+import { getResolvedConfig } from '../../shared/getResolvedConfig.js';
 export { pluginAutoFullBuild };
 export { isPrerenderForceExit };
 import { build } from 'vite';
@@ -15,7 +16,7 @@ import { isViteClientBuild, isViteServerBuild_onlySsrEnv } from '../../shared/is
 assertIsSingleModuleInstance('build/pluginAutoFullBuild.ts');
 let forceExit = false;
 function pluginAutoFullBuild() {
-    let config;
+    let vite5Config;
     let vikeConfig;
     return [
         {
@@ -24,7 +25,7 @@ function pluginAutoFullBuild() {
             enforce: 'pre',
             async configResolved(config_) {
                 vikeConfig = await getVikeConfig(config_);
-                config = config_;
+                vite5Config = config_;
                 abortViteBuildSsr(vikeConfig);
             },
             writeBundle: {
@@ -33,6 +34,7 @@ function pluginAutoFullBuild() {
                 order: 'pre',
                 */
                 async handler(options, bundle) {
+                    const config = getResolvedConfig(this.environment?.config, vite5Config);
                     await handleAssetsManifest(config, this.environment, options, bundle);
                     await triggerFullBuild(config, vikeConfig, this.environment, bundle);
                 }
@@ -46,6 +48,7 @@ function pluginAutoFullBuild() {
                 sequential: true,
                 order: 'post',
                 handler() {
+                    const config = getResolvedConfig(this.environment?.config, vite5Config);
                     onSetupBuild();
                     handleAssetsManifest_assertUsageCssTarget(config);
                     if (forceExit &&
@@ -90,7 +93,7 @@ async function triggerFullBuild(config, vikeConfig, viteEnv, bundle) {
         // The server bulid is already called by builder.buildApp()
     }
     if (isPrerenderAutoRunEnabled(vikeConfig)) {
-        const res = await runPrerenderFromAutoRun(configInline, config);
+        const res = await runPrerenderFromAutoRun(configInline);
         forceExit = res.forceExit;
     }
 }

package/dist/esm/node/plugin/plugins/build/pluginDistPackageJsonFile.js

@@ -7,18 +7,20 @@
  * Reproduction: https://github.com/brillout/vite-plugin-ssr-server-import-syntax
  */
 // TODO/refactor: prefix all other plugins with `plugin` as well?
+import { getResolvedConfig } from '../../shared/getResolvedConfig.js';
 export { pluginDistPackageJsonFile };
 import { rollupIsEsm } from '../../shared/rollupIsEsm.js';
 import { isViteServerBuild } from '../../shared/isViteServerBuild.js';
 function pluginDistPackageJsonFile() {
-    let config;
+    let vite5Config;
     return {
         name: 'vike:build:pluginDistPackageJsonFile',
         apply: 'build',
         configResolved(config_) {
-            config = config_;
+            vite5Config = config_;
         },
         generateBundle(options, bundle) {
+            const config = getResolvedConfig(this.environment?.config, vite5Config);
             if (!isViteServerBuild(config))
                 return;
             const isEsm = rollupIsEsm(options);

package/dist/esm/node/plugin/plugins/build/pluginModuleBanner.js

@@ -1,4 +1,6 @@
+import { getResolvedConfig } from '../../shared/getResolvedConfig.js';
 export { pluginModuleBanner };
+import MagicString from 'magic-string';
 import { assert } from '../../utils.js';
 import { removeVirtualIdTag } from '../../../shared/virtual-files.js';
 import { isViteServerBuild, isViteServerBuild_safe } from '../../shared/isViteServerBuild.js';
@@ -6,17 +8,18 @@ import { isViteServerBuild, isViteServerBuild_safe } from '../../shared/isViteSe
 // But, anyways, we want to prepend the banner at the beginning of each module, not at the beginning of each file (I believe that's what Rollup's banner feature does).
 const vikeModuleBannerPlaceholder = 'vikeModuleBannerPlaceholder';
 function pluginModuleBanner() {
-    let config;
+    let vite5Config;
     return {
         name: 'vike:pluginModuleBanner',
         enforce: 'post',
         apply: 'build',
         configResolved(config_) {
-            config = config_;
+            vite5Config = config_;
         },
         generateBundle: {
             order: 'post',
             handler(_options, bundle) {
+                const config = getResolvedConfig(this.environment?.config, vite5Config);
                 for (const module of Object.values(bundle)) {
                     if (module.type === 'chunk') {
                         if (isViteServerBuild(config)) {
@@ -35,6 +38,7 @@ function pluginModuleBanner() {
         transform: {
             order: 'post',
             handler(code, id, options) {
+                const config = getResolvedConfig(this.environment?.config, vite5Config);
                 if (!isViteServerBuild_safe(config, options))
                     return;
                 if (id.startsWith('\0'))
@@ -42,7 +46,13 @@ function pluginModuleBanner() {
                 id = removeVirtualIdTag(id);
                 if (id.startsWith(config.root))
                     id = id.slice(config.root.length + 1);
-                return `${vikeModuleBannerPlaceholder}(${JSON.stringify(id)}); ${code}`;
+                const s = new MagicString(code);
+                // No need to insert a new line; Rollup formats the code and will insert a new line.
+                s.prepend(`${vikeModuleBannerPlaceholder}(${JSON.stringify(id)}); `);
+                return {
+                    code: s.toString(),
+                    map: s.generateMap({ hires: true, source: id })
+                };
             }
         }
     };

package/dist/esm/node/plugin/plugins/commonConfig.d.ts

@@ -20,8 +20,14 @@ declare module 'vite' {
 type VikeConfigPublic = {
     config: VikeConfigObject['global']['config'];
     pages: VikeConfigObject['pages'];
-    prerenderContext?: PrerenderContextPublic;
+    prerenderContext: PrerenderContext;
 };
+type PrerenderContext = {
+    isPrerenderingEnabled: boolean;
+    isPrerenderingEnabledForAllPages: boolean;
+} & ({
+    [K in keyof PrerenderContextPublic]: null;
+} | PrerenderContextPublic);
 declare function commonConfig(vikeVitePluginOptions: unknown): Plugin[];
 /**
  * Get all the information Vike knows about the app in your Vite plugin.

package/dist/esm/node/plugin/plugins/commonConfig.js

@@ -14,6 +14,8 @@ import { temp_disablePrerenderAutoRun } from '../../prerender/context.js';
 import { resolvePrerenderConfigGlobal } from '../../prerender/resolvePrerenderConfig.js';
 const pluginName = 'vike:commonConfig';
 function commonConfig(vikeVitePluginOptions) {
+    // We cache it => makes sure we only generate one object => we can mutate it at runPrerender()
+    let prerenderContext;
     return [
         {
             name: `${pluginName}:pre`,
@@ -26,6 +28,15 @@ function commonConfig(vikeVitePluginOptions) {
                     const root = configFromUser.root ? normalizeViteRoot(configFromUser.root) : await getViteRoot(operation);
                     assert(root);
                     const vikeConfig = await getVikeConfig2(root, isDev, vikeVitePluginOptions);
+                    const { isPrerenderingEnabled, isPrerenderingEnabledForAllPages } = resolvePrerenderConfigGlobal(vikeConfig);
+                    prerenderContext ?? (prerenderContext = {
+                        isPrerenderingEnabled,
+                        isPrerenderingEnabledForAllPages,
+                        output: null,
+                        pageContexts: null
+                    });
+                    assert(prerenderContext.isPrerenderingEnabled === isPrerenderingEnabled);
+                    assert(prerenderContext.isPrerenderingEnabledForAllPages === isPrerenderingEnabledForAllPages);
                     return {
                         _isDev: isDev,
                         _root: root,
@@ -33,11 +44,12 @@ function commonConfig(vikeVitePluginOptions) {
                         _vikeConfigObject: vikeConfig,
                         _vike: {
                             pages: vikeConfig.pages,
-                            config: vikeConfig.global.config
+                            config: vikeConfig.global.config,
+                            prerenderContext
                         },
                         // TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
                         configVikePromise: Promise.resolve({
-                            prerender: resolvePrerenderConfigGlobal(vikeConfig).isPrerenderingEnabled
+                            prerender: isPrerenderingEnabled
                         })
                     };
                 }

package/dist/esm/node/plugin/plugins/devConfig/index.js

@@ -1,3 +1,4 @@
+import { getResolvedConfig } from '../../shared/getResolvedConfig.js';
 export { devConfig };
 export { logDockerHint };
 import { determineOptimizeDeps } from './determineOptimizeDeps.js';
@@ -12,7 +13,7 @@ if (isErrorDebug()) {
     Error.stackTraceLimit = Infinity;
 }
 function devConfig() {
-    let config;
+    let vite5Config;
     return [
         {
             name: 'vike:devConfig',
@@ -57,14 +58,14 @@ function devConfig() {
                 };
             },
             async configResolved(config_) {
-                config = config_;
-                await determineOptimizeDeps(config);
-                await determineFsAllowList(config);
+                vite5Config = config_;
+                await determineOptimizeDeps(vite5Config);
+                await determineFsAllowList(vite5Config);
                 if (!isErrorDebug()) {
                     await installHttpRequestAsyncStore();
-                    improveViteLogs(config);
+                    improveViteLogs(vite5Config);
                 }
-                logDockerHint(config.server.host);
+                logDockerHint(vite5Config.server.host);
             }
         },
         {
@@ -75,6 +76,7 @@ function devConfig() {
             configureServer: {
                 order: 'post',
                 handler(server) {
+                    const config = getResolvedConfig(server?.config, vite5Config);
                     const hasHonoViteDevServer = !!config.plugins.find((p) => p.name === '@hono/vite-dev-server');
                     if (config.server.middlewareMode || hasHonoViteDevServer)
                         return;

package/dist/esm/node/plugin/plugins/envVars.js

@@ -1,10 +1,11 @@
+import MagicString from 'magic-string';
 export { envVarsPlugin };
 import { loadEnv } from 'vite';
 import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArray, lowerFirst } from '../utils.js';
-import { sourceMapPassthrough } from '../shared/rollupSourceMap.js';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isViteServerBuild_safe } from '../shared/isViteServerBuild.js';
+import { getResolvedConfig } from '../shared/getResolvedConfig.js';
 // TODO/enventually: (after we implemented vike.config.js)
 // - Make import.meta.env work inside +config.js
 //   - For it to work, we'll probably need the user to define the settings (e.g. `envDir`) for loadEnv() inside vike.config.js instead of vite.config.js
@@ -16,17 +17,18 @@ const PUBLIC_ENV_WHITELIST = [
 ];
 function envVarsPlugin() {
     let envsAll;
-    let config;
+    let vite5Config;
     return {
         name: 'vike:envVars',
         enforce: 'post',
         configResolved(config_) {
-            config = config_;
-            config.command;
-            envsAll = loadEnv(config.mode, config.envDir || config.root, '');
-            config.plugins.sort(lowerFirst((plugin) => (plugin.name === 'vite:define' ? 1 : 0)));
+            vite5Config = config_;
+            vite5Config.command;
+            envsAll = loadEnv(vite5Config.mode, vite5Config.envDir || vite5Config.root, '');
+            vite5Config.plugins.sort(lowerFirst((plugin) => (plugin.name === 'vite:define' ? 1 : 0)));
         },
         transform(code, id, options) {
+            const config = getResolvedConfig(this.environment?.config, vite5Config);
             id = normalizeId(id);
             assertPosixPath(id);
             if (id.includes('/node_modules/'))
@@ -38,6 +40,7 @@ function envVarsPlugin() {
                 return;
             const isBuild = config.command === 'build';
             const isClientSide = !isViteServerBuild_safe(config, options);
+            const s = new MagicString(code);
             Object.entries(envsAll)
                 .filter(([key]) => {
                 // Already handled by Vite
@@ -46,12 +49,12 @@ function envVarsPlugin() {
             })
                 .forEach(([envName, envVal]) => {
                 const envStatement = `import.meta.env.${envName}`;
-                const envStatementRegEx = new RegExp(escapeRegex(envStatement) + '\\b', 'g');
+                const envStatementRegExStr = escapeRegex(envStatement) + '\\b';
                 // Security check
                 {
                     const isPrivate = !envName.startsWith(PUBLIC_ENV_PREFIX) && !PUBLIC_ENV_WHITELIST.includes(envName);
                     if (isPrivate && isClientSide) {
-                        if (!envStatementRegEx.test(code))
+                        if (!new RegExp(envStatementRegExStr).test(code))
                             return;
                         const modulePath = getModuleFilePathAbsolute(id, config);
                         const errMsgAddendum = isBuild ? '' : ' (Vike will prevent your app from building for production)';
@@ -70,16 +73,21 @@ function envVarsPlugin() {
                     assert(!(isPrivate && isClientSide) || !isBuild);
                 }
                 // Apply
-                code = applyEnvVar(envStatementRegEx, envVal, code);
+                applyEnvVar(s, envStatementRegExStr, envVal);
             });
-            // Line numbers didn't change.
-            //  - We only break the column number of a couple of lines, wich is acceptable.
-            //  - Anyways, I'm not even sure Vite supports high-resolution column number source mapping.
-            const ret = sourceMapPassthrough(code);
-            return ret;
+            if (!s.hasChanged())
+                return null;
+            return {
+                code: s.toString(),
+                map: s.generateMap({ hires: true, source: id })
+            };
         }
     };
 }
-function applyEnvVar(envStatementRegEx, envVal, code) {
-    return code.replace(envStatementRegEx, JSON.stringify(envVal));
+function applyEnvVar(s, envStatementRegExStr, envVal) {
+    const envStatementRegEx = new RegExp(envStatementRegExStr, 'g');
+    let match;
+    while ((match = envStatementRegEx.exec(s.original))) {
+        s.overwrite(match.index, match.index + match[0].length, JSON.stringify(envVal));
+    }
 }

package/dist/esm/node/plugin/plugins/extractAssetsPlugin.js

@@ -4,6 +4,7 @@
 //  - This is needed for HTML-only pages, and React Server Components.
 //  - We recommend using the debug flag to get an idea of how this plugin works: `$ DEBUG=vike:extractAssets pnpm exec vike build`. Then have a look at `dist/client/manifest.json` and see how `.page.server.js` entries have zero JavaScript but only CSS.
 //  - This appraoch supports import path aliases `vite.config.js#resolve.alias` https://vitejs.dev/config/#resolve-alias
+import { getResolvedConfig } from '../shared/getResolvedConfig.js';
 export { extractAssetsPlugin };
 export { extractAssetsRE };
 import { assert, assertPosixPath, styleFileRE, createDebugger, isScriptFile, assertUsage } from '../utils.js';
@@ -24,7 +25,7 @@ const urlRE = /(\?|&)url(?:&|$)/;
 const EMPTY_MODULE_ID = 'virtual:vike:empty-module';
 const debug = createDebugger('vike:extractAssets');
 function extractAssetsPlugin() {
-    let config;
+    let vite5Config;
     let vikeConfig;
     let isFixEnabled;
     return [
@@ -35,6 +36,7 @@ function extractAssetsPlugin() {
             apply: 'build',
             enforce: 'post',
             async transform(src, id, options) {
+                const config = getResolvedConfig(this.environment?.config, vite5Config);
                 id = normalizeId(id);
                 if (!extractAssetsRE.test(id)) {
                     return;
@@ -63,6 +65,7 @@ function extractAssetsPlugin() {
             //  - Vite's `vite:resolve` plugin; https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/resolve.ts#L105
             enforce: 'pre',
             async resolveId(source, importer, options) {
+                const config = getResolvedConfig(this.environment?.config, vite5Config);
                 if (isViteServerBuild_safe(config, options)) {
                     // When building for the server, there should never be a `?extractAssets` query
                     assert(!extractAssetsRE.test(source));
@@ -138,12 +141,12 @@ function extractAssetsPlugin() {
         {
             name: 'vike:extractAssets-4',
             async configResolved(config_) {
-                config = config_;
-                vikeConfig = await getVikeConfig(config);
-                isFixEnabled = handleAssetsManifest_isFixEnabled(config);
+                vite5Config = config_;
+                vikeConfig = await getVikeConfig(vite5Config);
+                isFixEnabled = handleAssetsManifest_isFixEnabled(vite5Config);
                 if (!isFixEnabled) {
                     // https://github.com/vikejs/vike/issues/1060
-                    assertUsage(!config.plugins.find((p) => p.name === 'vite-tsconfig-paths'), 'vite-tsconfig-paths not supported, remove it and use vite.config.js#resolve.alias instead');
+                    assertUsage(!vite5Config.plugins.find((p) => p.name === 'vite-tsconfig-paths'), 'vite-tsconfig-paths not supported, remove it and use vite.config.js#resolve.alias instead');
                 }
             }
         }