vike 0.4.241 → 0.4.242-commit-33026dc

package/dist/esm/node/api/build.js

@@ -7,16 +7,16 @@ import { createBuilder } from 'vite';
  * https://vike.dev/api#build
  */
 async function build(options = {}) {
-    const { viteConfigFromUserEnhanced } = await prepareViteApiCall(options, 'build');
+    const { viteConfigFromUserResolved } = await prepareViteApiCall(options, 'build');
     // Pass it to vike:build:pluginBuildApp
-    if (viteConfigFromUserEnhanced)
-        viteConfigFromUserEnhanced._viteConfigFromUserEnhanced = viteConfigFromUserEnhanced;
-    const builder = await createBuilder(viteConfigFromUserEnhanced);
+    if (viteConfigFromUserResolved)
+        viteConfigFromUserResolved._viteConfigFromUserResolved = viteConfigFromUserResolved;
+    const builder = await createBuilder(viteConfigFromUserResolved);
     // buildApp() is implemented by vike:build:pluginBuildApp
     await builder.buildApp();
     return {
-    /* We don't return `viteConfig` because `viteConfigFromUserEnhanced` is `InlineConfig` not `ResolvedConfig`
-    viteConfig: viteConfigFromUserEnhanced,
+    /* We don't return `viteConfig` because `viteConfigFromUserResolved` is `InlineConfig` not `ResolvedConfig`
+    viteConfig: viteConfigFromUserResolved,
     */
     };
 }

package/dist/esm/node/api/dev.js

@@ -7,8 +7,8 @@ import { createServer } from 'vite';
  * https://vike.dev/api#dev
  */
 async function dev(options = {}) {
-    const { viteConfigFromUserEnhanced } = await prepareViteApiCall(options, 'dev');
-    const server = await createServer(viteConfigFromUserEnhanced);
+    const { viteConfigFromUserResolved } = await prepareViteApiCall(options, 'dev');
+    const server = await createServer(viteConfigFromUserResolved);
     return {
         viteServer: server,
         viteConfig: server.config,

package/dist/esm/node/api/prepareViteApiCall.d.ts

@@ -1,13 +1,6 @@
 export { prepareViteApiCall };
-export { getViteRoot };
-export { assertViteRoot };
-export { normalizeViteRoot };
-import type { InlineConfig, ResolvedConfig } from 'vite';
 import type { ApiOptions, ApiOperation } from './types.js';
 declare function prepareViteApiCall(options: ApiOptions, operation: ApiOperation): Promise<{
-    viteConfigResolved: ResolvedConfig;
-    viteConfigFromUserEnhanced: InlineConfig | undefined;
+    viteConfigResolved: import("vite").ResolvedConfig;
+    viteConfigFromUserResolved: import("vite").InlineConfig | undefined;
 }>;
-declare function getViteRoot(operation: ApiOperation): Promise<string>;
-declare function normalizeViteRoot(root: string): string;
-declare function assertViteRoot(root: string, config: ResolvedConfig): void;

package/dist/esm/node/api/prepareViteApiCall.js

@@ -1,168 +1,16 @@
 export { prepareViteApiCall };
-export { getViteRoot };
-export { assertViteRoot };
-export { normalizeViteRoot };
-import { loadConfigFromFile, mergeConfig, resolveConfig } from 'vite';
 import { clearContextVikeApiOperation, setContextVikeApiOperation } from './context.js';
-import { getVikeConfigInternal, getVikeConfigFromCliOrEnv, setVikeConfigContext, } from '../vite/shared/resolveVikeConfigInternal.js';
-import path from 'node:path';
-import { assert, assertUsage, getGlobalObject, isObject, pick, toPosixPath } from './utils.js';
-import pc from '@brillout/picocolors';
 import { clearGlobalContext } from '../runtime/globalContext.js';
-import { getEnvVarObject } from '../vite/shared/getEnvVarObject.js';
-const globalObject = getGlobalObject('api/prepareViteApiCall.ts', {});
+import { getViteContextWithOperation, resolveViteConfigFromUser } from './resolveViteConfigFromUser.js';
 async function prepareViteApiCall(options, operation) {
     clear();
     setContextVikeApiOperation(operation, options);
-    const viteConfigFromUserApiOptions = options.viteConfig;
-    return resolveConfigs(viteConfigFromUserApiOptions, operation);
+    const viteConfigFromUserVikeApiOptions = options.viteConfig;
+    const viteContext = getViteContextWithOperation(operation);
+    return resolveViteConfigFromUser(viteConfigFromUserVikeApiOptions, viteContext);
 }
 // For subsequent API calls, e.g. calling prerender() after build()
 function clear() {
     clearContextVikeApiOperation();
     clearGlobalContext();
 }
-async function resolveConfigs(viteConfigFromUserApiOptions, operation) {
-    const viteInfo = await getViteInfo(viteConfigFromUserApiOptions, operation);
-    setVikeConfigContext({
-        userRootDir: viteInfo.root,
-        isDev: operation === 'dev',
-        vikeVitePluginOptions: viteInfo.vikeVitePluginOptions,
-    });
-    const vikeConfig = await getVikeConfigInternal();
-    const viteConfigFromUserEnhanced = applyVikeViteConfig(viteInfo.viteConfigFromUserEnhanced, vikeConfig);
-    const { viteConfigResolved } = await assertViteRoot2(viteInfo.root, viteConfigFromUserEnhanced, operation);
-    return {
-        viteConfigResolved, // ONLY USE if strictly necessary. (We plan to remove assertViteRoot2() as explained in the comments of that function.)
-        viteConfigFromUserEnhanced,
-    };
-}
-// Apply +vite
-// - For example, Vike extensions adding Vite plugins
-function applyVikeViteConfig(viteConfigFromUserEnhanced, vikeConfig) {
-    const viteConfigs = vikeConfig._from.configsCumulative.vite;
-    if (!viteConfigs)
-        return viteConfigFromUserEnhanced;
-    viteConfigs.values.forEach((v) => {
-        assertUsage(isObject(v.value), `${v.definedAt} should be an object`);
-        viteConfigFromUserEnhanced = mergeConfig(viteConfigFromUserEnhanced ?? {}, v.value);
-        assertUsage(!findVikeVitePlugin(v.value), "Using the +vite setting to add Vike's Vite plugin is forbidden");
-    });
-    return viteConfigFromUserEnhanced;
-}
-async function getViteRoot(operation) {
-    if (!globalObject.root)
-        await getViteInfo(undefined, operation);
-    assert(globalObject.root);
-    return globalObject.root;
-}
-async function getViteInfo(viteConfigFromUserApiOptions, operation) {
-    let viteConfigFromUserEnhanced = viteConfigFromUserApiOptions;
-    // Precedence:
-    //  1) viteConfigFromUserEnvVar (highest precedence)
-    //  2) viteConfigFromUserVikeConfig
-    //  2) viteConfigFromUserApiOptions
-    //  3) viteConfigFromUserViteFile (lowest precedence)
-    // Resolve Vike's +mode setting
-    {
-        const viteConfigFromUserVikeConfig = pick(getVikeConfigFromCliOrEnv().vikeConfigFromCliOrEnv, ['mode']);
-        if (Object.keys(viteConfigFromUserVikeConfig).length > 0) {
-            viteConfigFromUserEnhanced = mergeConfig(viteConfigFromUserEnhanced ?? {}, viteConfigFromUserVikeConfig);
-        }
-    }
-    // Resolve VITE_CONFIG
-    const viteConfigFromUserEnvVar = getEnvVarObject('VITE_CONFIG');
-    if (viteConfigFromUserEnvVar) {
-        viteConfigFromUserEnhanced = mergeConfig(viteConfigFromUserEnhanced ?? {}, viteConfigFromUserEnvVar);
-    }
-    // Resolve vite.config.js
-    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigFromUserEnhanced, operation);
-    // Correct precedence, replicates Vite:
-    // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1001
-    const viteConfigResolved = mergeConfig(viteConfigFromUserViteFile ?? {}, viteConfigFromUserEnhanced ?? {});
-    const root = normalizeViteRoot(viteConfigResolved.root ?? process.cwd());
-    globalObject.root = root;
-    // - Find options `vike(options)` set in vite.config.js
-    //   - TO-DO/next-major-release: remove
-    // - Add Vike's Vite plugin if missing
-    let vikeVitePluginOptions;
-    const found = findVikeVitePlugin(viteConfigResolved);
-    if (found) {
-        vikeVitePluginOptions = found.vikeVitePluginOptions;
-    }
-    else {
-        // Add Vike to plugins if not present.
-        // Using a dynamic import because the script calling the Vike API may not live in the same place as vite.config.js, thus vike/plugin may resolved to two different node_modules/vike directories.
-        const { plugin: vikePlugin } = await import('../vite/index.js');
-        viteConfigFromUserEnhanced = {
-            ...viteConfigFromUserEnhanced,
-            plugins: [...(viteConfigFromUserEnhanced?.plugins ?? []), vikePlugin()],
-        };
-        const res = findVikeVitePlugin(viteConfigFromUserEnhanced);
-        assert(res);
-        vikeVitePluginOptions = res.vikeVitePluginOptions;
-    }
-    assert(vikeVitePluginOptions);
-    return { root, vikeVitePluginOptions, viteConfigFromUserEnhanced };
-}
-function findVikeVitePlugin(viteConfig) {
-    let vikeVitePluginOptions;
-    let vikeVitePuginFound = false;
-    viteConfig?.plugins?.forEach((p) => {
-        if (p && '_vikeVitePluginOptions' in p) {
-            vikeVitePuginFound = true;
-            const options = p._vikeVitePluginOptions;
-            vikeVitePluginOptions ?? (vikeVitePluginOptions = {});
-            Object.assign(vikeVitePluginOptions, options);
-        }
-    });
-    if (!vikeVitePuginFound)
-        return null;
-    return { vikeVitePluginOptions };
-}
-// Copied from https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L961-L1005
-async function loadViteConfigFile(viteConfigFromUserApiOptions, operation) {
-    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfigFromUserApiOptions, operation);
-    let config = inlineConfig;
-    let mode = inlineConfig.mode || defaultMode;
-    const configEnv = {
-        mode,
-        command,
-        isSsrBuild: command === 'build' && !!config.build?.ssr,
-        isPreview,
-    };
-    let { configFile } = config;
-    if (configFile !== false) {
-        const loadResult = await loadConfigFromFile(configEnv, configFile, config.root, config.logLevel, config.customLogger);
-        return loadResult?.config;
-    }
-    return null;
-}
-function getResolveConfigArgs(viteConfig = {}, operation) {
-    const inlineConfig = viteConfig;
-    const command = operation === 'build' || operation === 'prerender' ? 'build' : 'serve';
-    const defaultMode = operation === 'dev' ? 'development' : 'production';
-    const defaultNodeEnv = defaultMode;
-    const isPreview = operation === 'preview';
-    return [inlineConfig, command, defaultMode, defaultNodeEnv, isPreview];
-}
-function normalizeViteRoot(root) {
-    // `path.resolve(viteConfigFromUserViteFile.configFile, root)` could be more intuitive than `path.resolve(process.cwd(), root)` but we replicate Vite's behavior (`vite.config.js` should follow Vite's API), see:
-    // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1063
-    return toPosixPath(
-    // Equivalent to `path.resolve(process.cwd(), root)`
-    path.resolve(root));
-}
-const errMsg = `A Vite plugin is modifying Vite's setting ${pc.cyan('root')} which is forbidden`;
-async function assertViteRoot2(root, viteConfigFromUserEnhanced, operation) {
-    const args = getResolveConfigArgs(viteConfigFromUserEnhanced, operation);
-    // We can eventually remove this resolveConfig() call (along with removing the whole assertViteRoot2() function which is redundant with the assertViteRoot() function) so that Vike doesn't make any resolveConfig() (except for pre-rendering and preview which is required). But let's keep it for now, just to see whether calling resolveConfig() can be problematic.
-    const viteConfigResolved = await resolveConfig(...args);
-    assertUsage(normalizeViteRoot(viteConfigResolved.root) === normalizeViteRoot(root), errMsg);
-    return { viteConfigResolved };
-}
-function assertViteRoot(root, config) {
-    if (globalObject.root)
-        assert(normalizeViteRoot(globalObject.root) === normalizeViteRoot(root));
-    assertUsage(normalizeViteRoot(root) === normalizeViteRoot(config.root), errMsg);
-}

package/dist/esm/node/api/prerender.js

@@ -7,8 +7,8 @@ import { prepareViteApiCall } from './prepareViteApiCall.js';
  * https://vike.dev/api#prerender
  */
 async function prerender(options = {}) {
-    const { viteConfigFromUserEnhanced } = await prepareViteApiCall(options, 'prerender');
-    options.viteConfig = viteConfigFromUserEnhanced;
+    const { viteConfigFromUserResolved } = await prepareViteApiCall(options, 'prerender');
+    options.viteConfig = viteConfigFromUserResolved;
     const { viteConfig } = await runPrerenderFromAPI(options);
     return {
         viteConfig,

package/dist/esm/node/api/preview.js

@@ -13,7 +13,7 @@ import path from 'node:path';
  */
 async function preview(options = {}) {
     onSetupPreview();
-    const { viteConfigFromUserEnhanced, viteConfigResolved } = await prepareViteApiCall(options, 'preview');
+    const { viteConfigFromUserResolved, viteConfigResolved } = await prepareViteApiCall(options, 'preview');
     if (viteConfigResolved.vitePluginServerEntry?.inject) {
         const outDir = getOutDirs(viteConfigResolved, undefined).outDirRoot;
         const { outServerIndex } = await importServerProductionIndex({ outDir });
@@ -24,7 +24,7 @@ async function preview(options = {}) {
         };
     }
     else {
-        const server = await previewVite(viteConfigFromUserEnhanced);
+        const server = await previewVite(viteConfigFromUserResolved);
         return {
             viteServer: server,
             viteConfig: server.config,

package/dist/esm/node/api/resolveViteConfigFromUser.d.ts

@@ -0,0 +1,20 @@
+export { resolveViteConfigFromUser };
+export { isOnlyResolvingUserConfig };
+export { getVikeConfigInternalEarly };
+export { getViteContextWithOperation };
+export { getViteRoot };
+export { assertViteRoot };
+export { normalizeViteRoot };
+import type { InlineConfig, ResolvedConfig } from 'vite';
+import type { ApiOperation } from './types.js';
+declare function resolveViteConfigFromUser(viteConfigFromUserVikeApiOptions: InlineConfig | undefined, viteContext: ViteContext): Promise<{
+    viteConfigResolved: ResolvedConfig;
+    viteConfigFromUserResolved: InlineConfig | undefined;
+}>;
+declare function getVikeConfigInternalEarly(): Promise<import("../vite/shared/resolveVikeConfigInternal.js").VikeConfigInternal>;
+declare function isOnlyResolvingUserConfig(): boolean | undefined;
+declare function getViteRoot(viteContext: ViteContext): Promise<string>;
+type ViteContext = 'build' | 'preview' | 'dev';
+declare function getViteContextWithOperation(operation: ApiOperation): ViteContext;
+declare function normalizeViteRoot(root: string): string;
+declare function assertViteRoot(root: string, config: ResolvedConfig): void;

package/dist/esm/node/api/resolveViteConfigFromUser.js

@@ -0,0 +1,207 @@
+export { resolveViteConfigFromUser };
+export { isOnlyResolvingUserConfig };
+export { getVikeConfigInternalEarly };
+export { getViteContextWithOperation };
+export { getViteRoot };
+export { assertViteRoot };
+export { normalizeViteRoot };
+import { loadConfigFromFile, mergeConfig, resolveConfig } from 'vite';
+import { getVikeConfigInternal, getVikeConfigFromCliOrEnv, setVikeConfigContext, isVikeConfigContextSet, } from '../vite/shared/resolveVikeConfigInternal.js';
+import path from 'node:path';
+import { assert, assertUsage, assertWarning, getGlobalObject, pick, toPosixPath } from './utils.js';
+import pc from '@brillout/picocolors';
+import { getEnvVarObject } from '../vite/shared/getEnvVarObject.js';
+import { getVikeApiOperation, isVikeCliOrApi } from './context.js';
+import { getViteCommandFromCli } from '../vite/shared/isViteCli.js';
+const globalObject = getGlobalObject('api/prepareViteApiCall.ts', {});
+async function resolveViteConfigFromUser(viteConfigFromUserVikeApiOptions, viteContext) {
+    const viteInfo = await getViteInfo(viteConfigFromUserVikeApiOptions, viteContext);
+    setVikeConfigContext_(viteInfo, viteContext);
+    const { viteConfigFromUserResolved } = viteInfo;
+    const { viteConfigResolved } = await assertViteRoot2(viteInfo.root, viteConfigFromUserResolved, viteContext);
+    return {
+        viteConfigResolved, // ONLY USE if strictly necessary. (We plan to remove assertViteRoot2() as explained in the comments of that function.)
+        viteConfigFromUserResolved,
+    };
+}
+async function getVikeConfigInternalEarly() {
+    assert(!globalObject.isOnlyResolvingUserConfig); // ensure no infinite loop
+    if (!isVikeConfigContextSet()) {
+        const viteContext = getViteContext();
+        const viteInfo = await getViteInfo(undefined, viteContext);
+        setVikeConfigContext_(viteInfo, viteContext);
+    }
+    return await getVikeConfigInternal();
+}
+function setVikeConfigContext_(viteInfo, viteContext) {
+    setVikeConfigContext({
+        userRootDir: viteInfo.root,
+        isDev: viteContext === 'dev',
+        vikeVitePluginOptions: viteInfo.vikeVitePluginOptions,
+    });
+}
+function isOnlyResolvingUserConfig() {
+    return globalObject.isOnlyResolvingUserConfig;
+}
+async function getViteRoot(viteContext) {
+    if (!globalObject.root)
+        await getViteInfo(undefined, viteContext);
+    assert(globalObject.root);
+    return globalObject.root;
+}
+async function getViteInfo(viteConfigFromUserVikeApiOptions, viteContext) {
+    let viteConfigFromUserResolved = viteConfigFromUserVikeApiOptions;
+    // Precedence:
+    //  1) viteConfigFromUserEnvVar (highest precedence)
+    //  2) viteConfigFromUserVikeConfig
+    //  2) viteConfigFromUserVikeApiOptions
+    //  3) viteConfigFromUserViteFile (lowest precedence)
+    // Resolve Vike's +mode setting
+    {
+        const viteConfigFromUserVikeConfig = pick(getVikeConfigFromCliOrEnv().vikeConfigFromCliOrEnv, ['mode']);
+        if (Object.keys(viteConfigFromUserVikeConfig).length > 0) {
+            viteConfigFromUserResolved = mergeConfig(viteConfigFromUserResolved ?? {}, viteConfigFromUserVikeConfig);
+        }
+    }
+    // Resolve VITE_CONFIG
+    const viteConfigFromUserEnvVar = getEnvVarObject('VITE_CONFIG');
+    if (viteConfigFromUserEnvVar) {
+        viteConfigFromUserResolved = mergeConfig(viteConfigFromUserResolved ?? {}, viteConfigFromUserEnvVar);
+    }
+    // Resolve vite.config.js
+    globalObject.isOnlyResolvingUserConfig = true;
+    const viteConfigFromUserViteConfigFile = await loadViteConfigFile(viteConfigFromUserResolved, viteContext);
+    globalObject.isOnlyResolvingUserConfig = false;
+    // Correct precedence, replicates Vite:
+    // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1001
+    const viteConfigResolved = mergeConfig(viteConfigFromUserViteConfigFile ?? {}, viteConfigFromUserResolved ?? {});
+    const root = normalizeViteRoot(viteConfigResolved.root ?? process.cwd());
+    globalObject.root = root;
+    // - Find options `vike(options)` set in vite.config.js
+    //   - TO-DO/next-major-release: remove
+    // - Add Vike's Vite plugin if missing
+    let vikeVitePluginOptions;
+    const found = findVikeVitePlugin(viteConfigResolved);
+    if (found) {
+        vikeVitePluginOptions = found.vikeVitePluginOptions;
+    }
+    else {
+        // Show a warning because Vike supports Vite's CLI (as well as third-party CLIs).
+        // - Encourage users to define a vite.config.js file that also works with Vite's CLI (and potentially other third-party CLIs).
+        // - Vike-based frameworks, such as DocPress, allow their users to omit defining a vite.config.js file.
+        assertWarning(viteConfigFromUserViteConfigFile, // Only show the warning if the user defined a vite.config.js file
+        "Omitting Vike's Vite plugin (inside your vite.config.js) is deprecated — make sure to always add Vike's Vite plugin https://vike.dev/vite-plugin", { onlyOnce: true });
+        // Add Vike to plugins if not present.
+        // Using a dynamic import because the script calling the Vike API may not live in the same place as vite.config.js, thus vike/plugin may resolved to two different node_modules/vike directories.
+        const { plugin: vikePlugin } = await import('../vite/index.js');
+        viteConfigFromUserResolved = {
+            ...viteConfigFromUserResolved,
+            plugins: [...(viteConfigFromUserResolved?.plugins ?? []), vikePlugin()],
+        };
+        const res = findVikeVitePlugin(viteConfigFromUserResolved);
+        assert(res);
+        vikeVitePluginOptions = res.vikeVitePluginOptions;
+    }
+    assert(vikeVitePluginOptions);
+    return { root, vikeVitePluginOptions, viteConfigFromUserResolved };
+}
+function findVikeVitePlugin(viteConfig) {
+    let vikeVitePluginOptions;
+    let vikeVitePuginFound = false;
+    viteConfig?.plugins?.forEach((p) => {
+        if (p && '_vikeVitePluginOptions' in p) {
+            vikeVitePuginFound = true;
+            const options = p._vikeVitePluginOptions;
+            vikeVitePluginOptions ?? (vikeVitePluginOptions = {});
+            Object.assign(vikeVitePluginOptions, options);
+        }
+    });
+    if (!vikeVitePuginFound)
+        return null;
+    return { vikeVitePluginOptions };
+}
+// Copied from https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L961-L1005
+async function loadViteConfigFile(viteConfigFromUserResolved, viteContext) {
+    const viteContextResolved = resolveViteContext(viteConfigFromUserResolved, viteContext);
+    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = viteContextResolved;
+    let config = inlineConfig;
+    let mode = inlineConfig.mode || defaultMode;
+    const configEnv = {
+        mode,
+        command,
+        isSsrBuild: command === 'build' && !!config.build?.ssr,
+        isPreview,
+    };
+    let { configFile } = config;
+    if (configFile !== false) {
+        const loadResult = await loadConfigFromFile(configEnv, configFile, config.root, config.logLevel, config.customLogger);
+        if (!loadResult)
+            return null;
+        assert(loadResult.config);
+        return loadResult.config;
+    }
+    return null;
+}
+function getViteContext() {
+    const vikeApiOperation = getVikeApiOperation();
+    const viteCommand = getViteCommandFromCli();
+    assert(!(viteCommand && vikeApiOperation));
+    if (vikeApiOperation)
+        return getViteContextWithOperation(vikeApiOperation.operation);
+    assert(!isVikeCliOrApi());
+    if (viteCommand === 'dev' || viteCommand === 'optimize') {
+        return 'dev';
+    }
+    if (viteCommand === 'build') {
+        return 'build';
+    }
+    if (viteCommand === 'preview') {
+        return 'preview';
+    }
+    // Third-party CLIs.
+    // - Component development (e.g. Storybook) => let's consider it development
+    // - Testing (e.g. Vitest) => let's consider it development
+    return 'dev';
+}
+function getViteContextWithOperation(operation) {
+    if (operation === 'build' || operation === 'prerender') {
+        return 'build';
+    }
+    if (operation === 'preview') {
+        return 'preview';
+    }
+    if (operation === 'dev') {
+        return 'dev';
+    }
+    assert(false);
+}
+function resolveViteContext(inlineConfig = {}, viteContext) {
+    const isBuild = viteContext === 'build';
+    const isPreview = viteContext === 'preview';
+    const isDev = viteContext === 'dev';
+    const command = isBuild ? 'build' : 'serve';
+    const defaultMode = isDev ? 'development' : 'production';
+    const defaultNodeEnv = defaultMode;
+    const viteContextResolved = [inlineConfig, command, defaultMode, defaultNodeEnv, isPreview];
+    return viteContextResolved;
+}
+function normalizeViteRoot(root) {
+    // `path.resolve(viteConfigFromUserViteFile.configFile, root)` could be more intuitive than `path.resolve(process.cwd(), root)` but we replicate Vite's behavior (`vite.config.js` should follow Vite's API), see:
+    // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1063
+    return toPosixPath(
+    // Equivalent to `path.resolve(process.cwd(), root)`
+    path.resolve(root));
+}
+const errMsg = `A Vite plugin is modifying Vite's setting ${pc.cyan('root')} which is forbidden`;
+async function assertViteRoot2(root, viteConfigFromUserResolved, viteContext) {
+    const viteContextResolved = resolveViteContext(viteConfigFromUserResolved, viteContext);
+    // We can eventually remove this resolveConfig() call (along with removing the whole assertViteRoot2() function which is redundant with the assertViteRoot() function) so that Vike doesn't make any resolveConfig() (except for pre-rendering and preview which is required). But let's keep it for now, just to see whether calling resolveConfig() can be problematic.
+    const viteConfigResolved = await resolveConfig(...viteContextResolved);
+    assertUsage(normalizeViteRoot(viteConfigResolved.root) === normalizeViteRoot(root), errMsg);
+    return { viteConfigResolved };
+}
+function assertViteRoot(root, config) {
+    if (globalObject.root)
+        assert(normalizeViteRoot(globalObject.root) === normalizeViteRoot(root));
+    assertUsage(normalizeViteRoot(root) === normalizeViteRoot(config.root), errMsg);
+}

package/dist/esm/node/prerender/runPrerenderEntry.js

@@ -6,7 +6,7 @@ import { assert } from './utils.js';
 import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
 import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
 import { isVikeCli } from '../cli/context.js';
-import { isViteCliCall } from '../vite/shared/isViteCliCall.js';
+import { isViteCli } from '../vite/shared/isViteCli.js';
 import { runPrerender } from './runPrerender.js';
 async function runPrerenderFromAPI(options = {}) {
     // - 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.
@@ -16,8 +16,8 @@ async function runPrerenderFromAPI(options = {}) {
 }
 async function runPrerenderFromCLIPrerenderCommand() {
     try {
-        const { viteConfigFromUserEnhanced } = await prepareViteApiCall({}, 'prerender');
-        await runPrerender({ viteConfig: viteConfigFromUserEnhanced }, '$ vike prerender');
+        const { viteConfigFromUserResolved } = await prepareViteApiCall({}, 'prerender');
+        await runPrerender({ viteConfig: viteConfigFromUserResolved }, '$ vike prerender');
     }
     catch (err) {
         console.error(err);
@@ -38,7 +38,7 @@ async function runPrerenderFromAutoRun(viteConfig) {
         logErrorHint(err);
         process.exit(1);
     }
-    const forceExit = isVikeCli() || isViteCliCall();
+    const forceExit = isVikeCli() || isViteCli();
     return { forceExit };
 }
 function runPrerender_forceExit() {

package/dist/esm/node/runtime/logErrorServer.js

@@ -1,9 +1,16 @@
 export { logErrorServer };
 import pc from '@brillout/picocolors';
-import { isObject } from './utils.js';
+import { isCallable, isObject } from './utils.js';
 import { execHookOnError } from './renderPage/execHookOnError.js';
 function logErrorServer(err) {
     execHookOnError(err);
+    // Set by react-streaming
+    // - https://github.com/brillout/react-streaming/blob/0fb5510d0a5a614f577668a519bccd62de40aed8/src/server/renderToStream/common.ts#L59-L62
+    // - https://gist.github.com/brillout/066293a687ab7cf695e62ad867bc6a9c
+    // - It doesn't seem to be needed? (The error Vike receives is already enhanced.) Should we remove this?
+    if (isObject(err) && isCallable(err.getEnhancedError)) {
+        err = err.getEnhancedError(err);
+    }
     // We ensure we print a string; Cloudflare Workers doesn't seem to properly stringify `Error` objects.
     // - TO-DO/eventually: is that still true? Let's eventually remove it and see if it crashes Cloudflare.
     const errStr = isObject(err) && 'stack' in err ? String(err.stack) : String(err);

package/dist/esm/node/runtime-dev/createDevMiddleware.js

@@ -18,8 +18,8 @@ async function createDevMiddleware(options = {}) {
             },
         },
     };
-    const { viteConfigFromUserEnhanced } = await prepareViteApiCall(optionsMod, 'dev');
-    const server = await createServer(viteConfigFromUserEnhanced);
+    const { viteConfigFromUserResolved } = await prepareViteApiCall(optionsMod, 'dev');
+    const server = await createServer(viteConfigFromUserResolved);
     const devMiddleware = server.middlewares;
     return { devMiddleware, viteServer: server, viteConfig: server.config };
 }

package/dist/esm/node/vite/index.d.ts

@@ -8,7 +8,7 @@ export type { VikeVitePluginOptions };
 type PluginInterop = Record<string, unknown> & {
     name: string;
 };
-declare function plugin(vikeVitePluginOptions?: VikeVitePluginOptions): PluginInterop[];
+declare function plugin(vikeVitePluginOptions?: VikeVitePluginOptions): Promise<PluginInterop[]>;
 /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
 type VikeVitePluginOptions = {
     /** @deprecated Define Vike settings in +config.js instead of vite.config.js */

package/dist/esm/node/vite/index.js

@@ -6,7 +6,7 @@ export { getVikeConfig } from './shared/resolveVikeConfigInternal.js';
 export { PROJECT_VERSION as version } from './utils.js';
 import { getClientEntrySrcDev } from './shared/getClientEntrySrcDev.js';
 import { setGetClientEntrySrcDev } from '../runtime/renderPage/getPageAssets/retrievePageAssetsDev.js';
-import { assertIsNotProductionRuntime, assertUsage } from './utils.js';
+import { assertIsNotProductionRuntime, assertUsage, isVitest } from './utils.js';
 import pc from '@brillout/picocolors';
 import { pluginPreview } from './plugins/pluginPreview.js';
 import { pluginDev } from './plugins/pluginDev.js';
@@ -31,31 +31,40 @@ import { pluginProdBuildEntry } from './plugins/build/pluginProdBuildEntry.js';
 import { pluginBuildConfig } from './plugins/build/pluginBuildConfig.js';
 import { pluginModuleBanner } from './plugins/build/pluginModuleBanner.js';
 import { pluginReplaceConstantsNonRunnableDev } from './plugins/non-runnable-dev/pluginReplaceConstantsNonRunnableDev.js';
+import { isVikeCliOrApi } from '../api/context.js';
+import { pluginViteConfigVikeExtensions } from './plugins/pluginViteConfigVikeExtensions.js';
+import { isOnlyResolvingUserConfig } from '../api/resolveViteConfigFromUser.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setGetClientEntrySrcDev(getClientEntrySrcDev);
 assertIsNotProductionRuntime();
 // Return `PluginInterop` instead of `Plugin` to avoid type mismatch upon different Vite versions
 function plugin(vikeVitePluginOptions = {}) {
-    const plugins = [
-        ...pluginCommon(vikeVitePluginOptions),
-        ...pluginVirtualFiles(),
-        ...pluginDev(),
-        ...pluginBuild(),
-        ...pluginPreview(),
-        ...pluginExtractAssets(),
-        ...pluginExtractExportNames(),
-        ...pluginSetGlobalContext(),
-        ...pluginBaseUrls(),
-        ...pluginReplaceConstantsEnvVars(),
-        ...pluginFileEnv(),
-        ...pluginWorkaroundCssModuleHmr(),
-        ...pluginWorkaroundVite6HmrRegression(),
-        ...pluginReplaceConstantsPageContext(),
-        ...pluginReplaceConstantsGlobalThis(),
-        ...pluginNonRunnabeDev(),
-    ];
-    Object.assign(plugins, { _vikeVitePluginOptions: vikeVitePluginOptions });
-    return plugins;
+    const promise = (async () => {
+        if (skip())
+            return [];
+        const plugins = [
+            ...pluginCommon(vikeVitePluginOptions),
+            ...pluginVirtualFiles(),
+            ...pluginDev(),
+            ...pluginBuild(),
+            ...pluginPreview(),
+            ...pluginExtractAssets(),
+            ...pluginExtractExportNames(),
+            ...pluginSetGlobalContext(),
+            ...pluginBaseUrls(),
+            ...pluginReplaceConstantsEnvVars(),
+            ...pluginFileEnv(),
+            ...pluginWorkaroundCssModuleHmr(),
+            ...pluginWorkaroundVite6HmrRegression(),
+            ...pluginReplaceConstantsPageContext(),
+            ...pluginReplaceConstantsGlobalThis(),
+            ...pluginNonRunnabeDev(),
+            ...(await pluginViteConfigVikeExtensions()),
+        ];
+        return plugins;
+    })();
+    Object.assign(promise, { _vikeVitePluginOptions: vikeVitePluginOptions });
+    return promise;
 }
 function pluginBuild() {
     return [
@@ -71,6 +80,28 @@ function pluginBuild() {
 function pluginNonRunnabeDev() {
     return [...pluginViteRPC(), ...pluginReplaceConstantsNonRunnableDev()];
 }
+function skip() {
+    // Early resolving of user Vite configs
+    if (isOnlyResolvingUserConfig()) {
+        return true;
+    }
+    // For Vitest, we only add Vike's Vite plugin if Vike's JavaScript API is used.
+    // - In the context of running unit tests with Vitest, Vike's Vite plugin doesn't add any value AFAICT.
+    // - If the user calls Vike's JavaScript API inside Vitest (e.g. `build()` inside `beforeAll()`)  => vite.config.js is loaded twice: once by Vitest and once by Vike => problematic because Vitest's environment is `development` whereas Vike's `build()` environment is `production` => the globalContext.ts isProd() function throws an assertion fail (I don't know why the two globalContext.ts instances aren't independent from each other) => that's why we skip Vike's Vite plugin when it's Vitest that loads vite.config.js
+    //   - When calling `$ vitest` Vitest loads vite.config.js if it lives at process.cwd()
+    // - The user is supposed to use Vike's API instead of Vite's API. Vike supports Vite's API only for third parties (e.g. Vitest or Storybook).
+    // - https://vike.dev/vitest
+    if (
+    /* Maybe also all third party tools such as Storybook?
+    !isViteCli() &&
+    /*/
+    isVitest() &&
+        ///*/
+        !isVikeCliOrApi()) {
+        return true;
+    }
+    return false;
+}
 // Error upon wrong usage
 Object.defineProperty(plugin, 'apply', {
     enumerable: true,