vike 0.4.240 → 0.4.241-commit-60b0676

package/dist/esm/client/runtime-client-routing/getPageContextFromHooks.d.ts

@@ -445,7 +445,7 @@ declare function getPageContextFromClientHooks(pageContext: {
 }>;
 type PageContextExecHookClient = PageContextConfig & PageContextForPublicUsageClient;
 declare function execHookClient(hookName: HookName, pageContext: PageContextExecHookClient): Promise<(import("../../shared/hooks/getHook.js").HookLoc & {
-    hookFn: (arg: import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum | import("../../shared/prepareGlobalContextForPublicUsage.js").GlobalContextPrepareMinimum) => unknown;
+    hookFn: (arg: import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum) => unknown;
     hookTimeout: import("../../shared/hooks/getHook.js").HookTimeout;
 } & {
     hookReturn: unknown;

package/dist/esm/client/runtime-client-routing/getPageContextFromHooks.js

@@ -168,7 +168,7 @@ function hasServerOnlyHook(pageContext) {
     if (isOldDesign(pageContext))
         return false;
     const pageConfig = getPageConfig(pageContext.pageId, pageContext._globalContext._pageConfigs);
-    const val = getConfigValueRuntime(pageConfig, `serverOnlyHooks`)?.value;
+    const val = getConfigValueRuntime(pageConfig, `hasServerOnlyHook`)?.value;
     assert(val === true || val === false);
     return val;
 }

package/dist/esm/client/runtime-client-routing/logErrorClient.d.ts

@@ -0,0 +1,2 @@
+export { logErrorClient };
+declare function logErrorClient(err: unknown): void;

package/dist/esm/client/runtime-client-routing/logErrorClient.js

@@ -0,0 +1,11 @@
+export { logErrorClient };
+import { isObject } from './utils.js';
+function logErrorClient(err) {
+    if (isObject(err) &&
+        // Set by vike-react
+        // https://github.com/vikejs/vike-react/blob/195a208c6b77e7f34496e1f637278a36c60fbe07/packages/vike-react/src/integration/onRenderClient.tsx#L109
+        err.isAlreadyLogged) {
+        return;
+    }
+    console.error(err);
+}

package/dist/esm/client/runtime-client-routing/renderPageClientSide.js

@@ -3,7 +3,7 @@ export { getRenderCount };
 export { disableClientRouting };
 export { firstRenderStartPromise };
 export { getPageContextClient };
-import { assert, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, hasProp, updateType, genPromise, isCallable, catchInfiniteLoop, } from './utils.js';
+import { assert, objectAssign, redirectHard, getGlobalObject, hasProp, updateType, genPromise, isCallable, catchInfiniteLoop, } from './utils.js';
 import { getPageContextFromClientHooks, getPageContextFromServerHooks, getPageContextFromHooks_isHydration, getPageContextFromHooks_serialized, setPageContextInitIsPassedToClient, } from './getPageContextFromHooks.js';
 import { createPageContextClientSide } from './createPageContextClientSide.js';
 import { addLinkPrefetchHandlers, addLinkPrefetchHandlers_unwatch, addLinkPrefetchHandlers_watch, getPageContextPrefetched, populatePageContextPrefetchCache, } from './prefetch.js';
@@ -24,6 +24,7 @@ import { execHookDirect, execHook } from '../../shared/hooks/execHook.js';
 import { preparePageContextForPublicUsageClient, } from './preparePageContextForPublicUsageClient.js';
 import { getHookFromPageContextNew } from '../../shared/hooks/getHook.js';
 import { preparePageContextForPublicUsageClientMinimal } from '../shared/preparePageContextForPublicUsageClientShared.js';
+import { logErrorClient } from './logErrorClient.js';
 const globalObject = getGlobalObject('runtime-client-routing/renderPageClientSide.ts', (() => {
     const { promise: firstRenderStartPromise, resolve: firstRenderStartPromiseResolve } = genPromise();
     return {
@@ -60,7 +61,7 @@ async function renderPageClientSide(renderArgs) {
     return;
     async function renderPageNominal() {
         const onError = async (err) => {
-            await renderPageOnError({ err });
+            await handleError({ err });
         };
         const pageContext = await getPageContextBegin(false, pageContextBeginArgs);
         if (isRenderOutdated())
@@ -229,96 +230,68 @@ async function renderPageClientSide(renderArgs) {
             await renderPageView(pageContext);
         }
     }
-    // When the normal page threw an error
+    // When the normal page threw an error:
     // - Can be a URL rewrite upon `throw render('/some-url')`
     // - Can be rendering the error page
     // - Can be rendering Vike's generic error page (if no error page is defined, or if the error page throws an error)
-    async function renderPageOnError(args) {
-        const onError = (err) => {
-            if (!isSameErrorMessage(err, args.err)) {
-                /* When we can't render the error page, we prefer showing a blank page over letting the server-side try because otherwise:
-                   - We risk running into an infinite loop of reloads which would overload the server.
-                   - An infinite reloading page is a even worse UX than a blank page.
-                redirectHard(urlOriginal)
-                */
-                console.error(err);
-            }
-        };
-        if ('err' in args) {
-            const { err } = args;
-            assert(err);
-            if (!isAbortError(err)) {
-                // We don't swallow 404 errors:
-                //  - On the server-side, Vike swallows / doesn't show any 404 error log because it's expected that a user may go to some random non-existent URL. (We don't want to flood the app's error tracking with 404 logs.)
-                //  - On the client-side, if the user navigates to a 404 then it means that the UI has a broken link. (It isn't expected that users can go to some random URL using the client-side router, as it would require, for example, the user to manually change the URL of a link by manually manipulating the DOM which highly unlikely.)
-                console.error(err);
-            }
-            else {
-                // We swallow throw redirect()/render() called by client-side hooks onBeforeRender()/data()/guard()
-                // We handle the abort error down below.
-            }
+    async function handleError(args) {
+        const { err } = args;
+        assert(err);
+        // Logging
+        if (!isAbortError(err)) {
+            // We don't swallow 404 errors:
+            //  - On the server-side, Vike swallows / doesn't show any 404 error log because it's expected that a user may go to some random non-existent URL. (We don't want to flood the app's error tracking with 404 logs.)
+            //  - On the client-side, if the user navigates to a 404 then it means that the UI has a broken link. (It isn't expected that users can go to some random URL using the client-side router, as it would require, for example, the user to manually change the URL of a link by manually manipulating the DOM which highly unlikely.)
+            logErrorClient(err);
+        }
+        else {
+            // We swallow throw redirect()/render() called by client-side hooks onBeforeRender()/data()/guard()
+            // We handle the abort error down below.
         }
+        // pageContext
         const pageContext = await getPageContextBegin(true, pageContextBeginArgs);
         if (isRenderOutdated())
             return;
-        objectAssign(pageContext, { routeParams: {} });
-        if (args.pageContextError)
-            objectAssign(pageContext, args.pageContextError);
-        if ('err' in args) {
-            const { err } = args;
-            assert(!('errorWhileRendering' in pageContext));
-            objectAssign(pageContext, { errorWhileRendering: err });
-            if (isAbortError(err)) {
-                const errAbort = err;
-                logAbortErrorHandled(err, !import.meta.env.DEV, pageContext);
-                const pageContextAbort = errAbort._pageContextAbort;
-                // throw render('/some-url')
-                if (pageContextAbort._urlRewrite) {
-                    await renderPageClientSide({
-                        ...renderArgs,
-                        scrollTarget: undefined,
-                        pageContextsFromRewrite: [...pageContextsFromRewrite, pageContextAbort],
-                    });
-                    return;
-                }
-                // throw redirect('/some-url')
-                if (pageContextAbort._urlRedirect) {
-                    const urlRedirect = pageContextAbort._urlRedirect.url;
-                    if (!urlRedirect.startsWith('/')) {
-                        // External redirection
-                        redirectHard(urlRedirect);
-                        return;
-                    }
-                    else {
-                        await renderPageClientSide({
-                            ...renderArgs,
-                            scrollTarget: undefined,
-                            urlOriginal: urlRedirect,
-                            overwriteLastHistoryEntry: false,
-                            isBackwardNavigation: false,
-                            redirectCount: redirectCount + 1,
-                        });
-                    }
-                    return;
-                }
-                // throw render(statusCode)
-                assert(pageContextAbort.abortStatusCode);
-                assert(!('urlOriginal' in pageContextAbort));
-                objectAssign(pageContext, pageContextAbort);
-                if (pageContextAbort.abortStatusCode === 404) {
-                    objectAssign(pageContext, { is404: true });
-                }
-            }
-            else {
-                objectAssign(pageContext, { is404: false });
-            }
+        objectAssign(pageContext, {
+            errorWhileRendering: err,
+        });
+        // throw redirect()/render()
+        let pageContextAbort;
+        if (isAbortError(err)) {
+            const res = await handleAbortError(err, pageContext);
+            if (res.skip)
+                return;
+            pageContextAbort = res.pageContextAbort;
         }
+        // Render error page
+        await renderErrorPage(pageContext, args, pageContextAbort);
+    }
+    async function renderErrorPage(pageContext, args, pageContextAbort) {
+        const onError = (err) => {
+            /* When we can't render the error page, we prefer showing a blank page over letting the server-side try because otherwise:
+               - We risk running into an infinite loop of reloads which would overload the server.
+               - An infinite reloading page is a even worse UX than a blank page.
+            redirectHard(urlOriginal)
+            */
+            logErrorClient(err);
+        };
         const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._globalContext._pageConfigs);
         if (!errorPageId)
             throw new Error('No error page defined.');
         objectAssign(pageContext, {
             pageId: errorPageId,
+            routeParams: {},
         });
+        // throw render(statusCode)
+        if (pageContextAbort) {
+            assert(pageContextAbort.abortStatusCode);
+            assert(!('urlOriginal' in pageContextAbort));
+            objectAssign(pageContext, pageContextAbort);
+            objectAssign(pageContext, { is404: pageContextAbort.abortStatusCode === 404 });
+        }
+        else {
+            objectAssign(pageContext, { is404: false });
+        }
         const isClientRoutable = await isClientSideRoutable(pageContext.pageId, pageContext);
         if (isRenderOutdated())
             return;
@@ -326,6 +299,9 @@ async function renderPageClientSide(renderArgs) {
             redirectHard(urlOriginal);
             return;
         }
+        if (import.meta.env.DEV || globalThis.__VIKE__IS_DEBUG) {
+            assertInfo(false, `Rendering error page ${errorPageId}`, { onlyOnce: false });
+        }
         const res = await loadPageConfigsLazyClientSideAndExecHook(pageContext, isFirstRender, isRenderOutdated);
         /* Already called inside loadPageConfigsLazyClientSideAndExecHook()
         if (isRenderOutdated()) return
@@ -367,15 +343,49 @@ async function renderPageClientSide(renderArgs) {
         updateType(pageContext, pageContextFromClientHooks);
         await renderPageView(pageContext, args);
     }
+    async function handleAbortError(err, pageContext) {
+        const errAbort = err;
+        logAbortErrorHandled(err, !import.meta.env.DEV, pageContext);
+        const pageContextAbort = errAbort._pageContextAbort;
+        // throw render('/some-url')
+        if (pageContextAbort._urlRewrite) {
+            await renderPageClientSide({
+                ...renderArgs,
+                scrollTarget: undefined,
+                pageContextsFromRewrite: [...pageContextsFromRewrite, pageContextAbort],
+            });
+            return { skip: true };
+        }
+        // throw redirect('/some-url')
+        if (pageContextAbort._urlRedirect) {
+            const urlRedirect = pageContextAbort._urlRedirect.url;
+            if (!urlRedirect.startsWith('/')) {
+                // External redirection
+                redirectHard(urlRedirect);
+                return { skip: true };
+            }
+            else {
+                await renderPageClientSide({
+                    ...renderArgs,
+                    scrollTarget: undefined,
+                    urlOriginal: urlRedirect,
+                    overwriteLastHistoryEntry: false,
+                    isBackwardNavigation: false,
+                    redirectCount: redirectCount + 1,
+                });
+            }
+            return { skip: true };
+        }
+        // throw render(statusCode)
+        return { pageContextAbort };
+    }
     async function renderPageView(pageContext, isErrorPage) {
         const onError = async (err) => {
             if (!isErrorPage) {
-                await renderPageOnError({ err });
+                await handleError({ err });
             }
             else {
-                if (!isSameErrorMessage(err, isErrorPage.err)) {
-                    console.error(err);
-                }
+                logErrorClient(err);
             }
         };
         // We use globalObject.onRenderClientPreviousPromise in order to ensure that there is never two concurrent onRenderClient() calls
@@ -395,6 +405,7 @@ async function renderPageClientSide(renderArgs) {
                 await execHookOnRenderClient(pageContext, preparePageContextForPublicUsageClient);
             }
             catch (err) {
+                assert(err);
                 onRenderClientError = err;
             }
             globalObject.onRenderClientPreviousPromise = undefined;
@@ -505,10 +516,10 @@ function changeUrl(url, overwriteLastHistoryEntry) {
     pushHistoryState(url, overwriteLastHistoryEntry);
 }
 function disableClientRouting(err, log) {
-    assert(isErrorFetchingStaticAssets(err));
     globalObject.clientRoutingIsDisabled = true;
+    assert(isErrorFetchingStaticAssets(err));
     if (log) {
-        // We don't use console.error() to avoid flooding error trackers such as Sentry
+        // We purposely don't use console.error() to avoid flooding error trackers such as Sentry
         console.log(err);
     }
     assertInfo(false, [

package/dist/esm/client/runtime-client-routing/utils.d.ts

@@ -7,7 +7,6 @@ export * from '../../utils/isCallable.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/isReact.js';
-export * from '../../utils/isSameErrorMessage.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/parseUrl.js';
 export * from '../../utils/PromiseType.js';

package/dist/esm/client/runtime-client-routing/utils.js

@@ -11,7 +11,6 @@ export * from '../../utils/isCallable.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/isReact.js';
-export * from '../../utils/isSameErrorMessage.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/parseUrl.js';
 export * from '../../utils/PromiseType.js';

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;